/// <summary>
/// 更新処理(Renderingで処理される)
/// </summary>
private void Update(Object sender, EventArgs e)
{
if (0 <= NativeMethods.GetKeyState(NativeMethods.VK_MIDDLE))
{
((Popup)this.Parent).IsOpen = false;
return;
}
if (NativeMethods.GetCursorPos(out var point))
{
var currentMousePos = new Point(point.X, point.Y);
var move = (currentMousePos - _prevMousePos).X;
if (IncrementMouseMoveThreshold < Math.Abs(move))
{
var inc = (move < 0.0) ? -_addUnit : _addUnit;
if (IncrementMouseMoveXFixed)
{
NativeMethods.SetCursorPos((Int32)_prevMousePos.X, (Int32)currentMousePos.Y);
}
else
{
_prevMousePos = currentMousePos;
}
Incremented?.Invoke(this, new IncrementedEventArgs()
{
Increment = (Decimal)inc
});
}
}
}
public void MergeFrom(CounterEvent other)
{
if (other == null)
{
return;
}
if (other.Id.Length != 0)
{
Id = other.Id;
}
if (other.Version != 0UL)
{
Version = other.Version;
}
switch (other.EventCase)
{
case EventOneofCase.Added:
if (Added == null)
{
Added = new global::CounterAdded();
}
Added.MergeFrom(other.Added);
break;
case EventOneofCase.Decremented:
if (Decremented == null)
{
Decremented = new global::CounterDecremented();
}
Decremented.MergeFrom(other.Decremented);
break;
case EventOneofCase.Incremented:
if (Incremented == null)
{
Incremented = new global::CounterIncremented();
}
Incremented.MergeFrom(other.Incremented);
break;
case EventOneofCase.NameChanged:
if (NameChanged == null)
{
NameChanged = new global::CounterNameChanged();
}
NameChanged.MergeFrom(other.NameChanged);
break;
case EventOneofCase.Removed:
if (Removed == null)
{
Removed = new global::CounterRemoved();
}
Removed.MergeFrom(other.Removed);
break;
}
_unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
}
private void iObservable_Incremented(int i_Increment)
{
if (m_ProgressBar != null)
{
m_ProgressBar.Increment(i_Increment);
m_Value += i_Increment;
}
if (Incremented != null)
{
Incremented.Invoke(i_Increment);
}
}
public void IncrementByOne()
{
m_ProgressBar.Value++;
if (Incremented != null)
{
Incremented.Invoke(1);
}
if (m_ProgressBar.Value == m_ProgressBar.Maximum)
{
if (Finished != null)
{
Finished.Invoke();
}
}
}
/// <summary> Increments the refcount for the given item. </summary>
/// <remarks>This method is thread-safe.</remarks>
/// <param name="item">The item that should be retained.</param>
public void Retain([CanBeNull] TItem item)
{
if (ReferenceEquals(item, null))
{
return;
}
_refs.AddOrUpdate(
item,
_ => {
var freshRef = new ItemRefCount(1);
FirstTimeRetained.Call(item);
Incremented.Call(item);
return(freshRef);
},
(_, existingRef) => {
existingRef.Inc();
Incremented.Call(item);
return(existingRef);
});
}
public override int GetHashCode()
{
int hash = 1;
if (Id.Length != 0)
{
hash ^= Id.GetHashCode();
}
if (Version != 0UL)
{
hash ^= Version.GetHashCode();
}
if (eventCase_ == EventOneofCase.Added)
{
hash ^= Added.GetHashCode();
}
if (eventCase_ == EventOneofCase.Decremented)
{
hash ^= Decremented.GetHashCode();
}
if (eventCase_ == EventOneofCase.Incremented)
{
hash ^= Incremented.GetHashCode();
}
if (eventCase_ == EventOneofCase.NameChanged)
{
hash ^= NameChanged.GetHashCode();
}
if (eventCase_ == EventOneofCase.Removed)
{
hash ^= Removed.GetHashCode();
}
hash ^= (int)eventCase_;
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
public void Increment()
{
_currentCount++;
Incremented?.Invoke(_currentCount);
}
protected void Increment()
{
Incremented?.Invoke(_counter++);
}
