public CollectionChangingEventArgs(CollectionChangeAction action, T element)
{
Action = action;
Element = element;
Cancel = false;
}
private void ResetEventData()
{
times = 0;
eventhandled = false;
Element = null;
Action = (CollectionChangeAction)0;
}
private void OnUnitCollectionChange(CollectionChangeAction action, object element)
{
if (this.StandardUnitCollectionChange != null)
{
this.StandardUnitCollectionChange(this, new CollectionChangeEventArgs(action, element));
}
}
public CollectionChangingEventArgs(T item, int index, CollectionChangeAction action)
{
Cancel = false;
Item = item;
Index = index;
Action = action;
}
protected void OnCollectionChange(CollectionChangeAction action, object element)
{
if (CollectionChanged != null)
{
CollectionChanged(this, new CollectionChangeEventArgs(action, element));
}
}
private void OnCollectionChanged(CollectionChangeAction action, ConfigurationElement element)
{
if (PropertyChanged != null)
{
CollectionChanged(this, new CollectionChangeEventArgs(action, element));
}
}
private void OnCityImprovementCollectionChange(CollectionChangeAction action, object element)
{
if (this.CityImprovementCollectionChange != null)
{
this.CityImprovementCollectionChange(this, new CollectionChangeEventArgs(action, element));
}
}
private void Add_CustRefChanged
(object sender, CollectionChangeEventArgs e)
{
CollectionChangeAction act = e.Action;
var custOnOtherEnd = (Contact)e.Element;
//add your logic here
}
public void Ctor_Action_Element(CollectionChangeAction action, object element)
{
var args = new CollectionChangeEventArgs(action, element);
Assert.Equal(action, args.Action);
Assert.Same(element, args.Element);
}
private void NotifyChanged(CollectionChangeAction action, CodeStatement option, int index)
{
if (_changed != null)
{
_changed(action, option, index);
}
}
//private void OnEventHandler (object sender, EventArgs e)
//{
// eventhandled = true;
//}
private void OnCollectionEventHandler(object sender, CollectionChangeEventArgs e)
{
eventhandled = true;
Element = e.Element;
Action = e.Action;
times++;
}
private void OnFortressDistrictCollectionChange(CollectionChangeAction action, object element)
{
if (this.FortressDistrictCollectionChange != null)
{
this.FortressDistrictCollectionChange(this, new CollectionChangeEventArgs(action, element));
}
}
private bool OnCollectionChanging(CollectionChangeAction action, T item)
{
var eventArgs = new CollectionChangingEventArgs <T>(action, item);
CollectionChanging(this, eventArgs);
return(eventArgs.Cancel);
}
public CollectionChangedEventArgs(IEnumerable <Highlight> highlights)
{
Index = -1;
OldItem = null;
NewItem = null;
RemovedItems = highlights.ToArray();
Action = CollectionChangeAction.Clear;
}
public CollectionChangedEventArgs(int index, Highlight oldItem, Highlight newItem)
{
Index = index;
OldItem = oldItem;
NewItem = newItem;
RemovedItems = new Highlight[0];
Action = CollectionChangeAction.Change;
}
public CollectionChangedEventArgs(int index, Highlight oldItem)
{
Index = index;
OldItem = oldItem;
NewItem = null;
RemovedItems = new Highlight[] { oldItem };
Action = CollectionChangeAction.Remove;
}
public CollectionChangedEventArgs(Highlight newItem, int index)
{
Index = index;
OldItem = null;
NewItem = newItem;
RemovedItems = new Highlight[0];
Action = CollectionChangeAction.Change;
}
private void ProcessExportGroup(ExportGroupVm exportGroup, CollectionChangeAction action)
{
foreach (var exportGroupVm in exportGroup.ExportGroups)
{
this.ProcessExportGroup(exportGroupVm, action);
}
this.ProcessExports(exportGroup, action);
}
private void checkLockModifyChangeAction(CollectionChangeAction collectionChangeAction)
{
if (lockModifyChangeActionsKeys.ContainsKey(collectionChangeAction))
{
throw new ObservableComputationsException(this,
"Modifying of '{collectionChangeAction.ToString()}' change action is locked. Unlock first.");
}
}
public ElementCollectionChangedEventArgs(IElementCollection collection,
CollectionChangeAction action,
IEnumerable <CollectionChangeItemInfo> changedItems)
{
Collection = collection;
Action = action;
ChangedItems = changedItems.ToArray();
ElementType = ChangedItems[0].Element.GetElementType();
}
private void fireEvent(CollectionChangeAction collectionChangeAction, Object collection,
CollectionChangeEventHandler e)
{
if (e != null)
{
CollectionChangeEventArgs args = new CollectionChangeEventArgs(collectionChangeAction, collection);
e(this, args);
}
}
private DataSourceChangedEventArgs(DataSourceChangeTypeEnum changeType, bool dataWasChanged, string propertyName,
CollectionChangeAction action, object element)
{
ChangeType = changeType;
DataWasUpdated = dataWasChanged;
PropertyName = propertyName;
Action = action;
Element = element;
}
private void ProcessExports(ExportGroupVm exportGroup, CollectionChangeAction action)
{
foreach (var snooperExport in exportGroup.ExportGroup.Exports)
{
var exports = (snooperExport as SnooperExportBase)?.ExportObjects;
if (exports == null)
{
continue;
}
foreach (var snooperExportedObjectBase in exports)
{
var sipMessages = (snooperExportedObjectBase as SIPEvent)?.SipMessages;
if (sipMessages == null)
{
continue;
}
foreach (var sipMsg in sipMessages)
{
switch (action)
{
case CollectionChangeAction.Add:
{
DispatcherHelper.CheckBeginInvokeOnUI(() => { this.SipMessages.AddNew(sipMsg); });
if (sipMsg.RequestLine?.Method == "INVITE")
{
var to = sipMsg.Headers.To.Substring(sipMsg.Headers.To.IndexOf("sip:") + 4).TrimEnd('>');
var reverseTo = ReverseString(to);
this.PrefixTrie.Add(reverseTo, sipMsg);
}
}
break;
case CollectionChangeAction.Remove:
{
DispatcherHelper.CheckBeginInvokeOnUI(() => { this.SipMessages.Remove(sipMsg); });
if (sipMsg.RequestLine?.Method == "INVITE")
{
var to = sipMsg.Headers.To.Substring(sipMsg.Headers.To.IndexOf("sip:") + 4).TrimEnd('>');
var reverseTo = ReverseString(to);
if (this.PrefixTrie.Contains(reverseTo, sipMsg))
{
this.PrefixTrie.Remove(reverseTo);
}
}
}
break;
}
}
}
}
}
public ElementCollectionChangedEventArgs(IElementCollection collection,
CollectionChangeAction action,
IEnumerable <CollectionChangeItemInfo> changedItems)
{
Collection = collection;
Action = action;
ChangedItems = changedItems.ToArray();
ElementType = CollectionExtensions.GetCollectionType(collection.GetType());
if (ElementType == null)
{
ElementType = ChangedItems[0].Element.GetElementType();
}
}
// -------
// Methods
// -------
internal override void OnAssociationChanged(CollectionChangeAction collectionChangeAction, object entity)
{
Debug.Assert(!(entity is IEntityWrapper), "Object is an IEntityWrapper instance instead of the raw entity.");
if (!_suppressEvents)
{
if (_onAssociationChangedforObjectView != null)
{
_onAssociationChangedforObjectView(this, (new CollectionChangeEventArgs(collectionChangeAction, entity)));
}
if (_onAssociationChanged != null)
{
_onAssociationChanged(this, (new CollectionChangeEventArgs(collectionChangeAction, entity)));
}
}
}
private void CheckMessage(XenAPI.Message m, CollectionChangeAction a)
{
if (!m.ShowOnGraphs() || m.cls != cls.VM)
{
return;
}
Host h = XenObject as Host;
if (h != null)
{
List <VM> resVMs = h.Connection.ResolveAll <VM>(h.resident_VMs);
foreach (VM v in resVMs)
{
if (v.uuid == m.obj_uuid)
{
if (a == CollectionChangeAction.Add)
{
DataEventList.AddEvent(new DataEvent(m.timestamp.ToLocalTime().Ticks, 0, m));
}
else
{
DataEventList.RemoveEvent(new DataEvent(m.timestamp.ToLocalTime().Ticks, 0, m));
}
break;
}
}
}
else if (XenObject is VM)
{
if (m.obj_uuid != Helpers.GetUuid(XenObject))
{
return;
}
if (a == CollectionChangeAction.Add)
{
DataEventList.AddEvent(new DataEvent(m.timestamp.ToLocalTime().Ticks, 0, m));
}
else
{
DataEventList.RemoveEvent(new DataEvent(m.timestamp.ToLocalTime().Ticks, 0, m));
}
}
}
public void LockModifyChangeAction(CollectionChangeAction collectionChangeAction, object key)
{
if (key == null)
{
throw new ArgumentNullException("key");
}
if (!lockModifyChangeActionsKeys.ContainsKey(collectionChangeAction))
{
lockModifyChangeActionsKeys[collectionChangeAction] = key;
}
else
{
throw new ObservableComputationsException(this,
$"Modifying of '{collectionChangeAction.ToString()}' change action is already locked. Unlock first.");
}
}
private void DepartmentOfTheInterior_CitiesCollectionChanged(object sender, CollectionChangeEventArgs e)
{
CollectionChangeAction action = e.Action;
if (action == CollectionChangeAction.Remove)
{
City city = e.Element as City;
Diagnostics.Assert(city != null);
ApprovalStatus oldStatus = null;
if (this.approvalStatusByGameEntity.ContainsKey(city.GUID))
{
oldStatus = this.approvalStatusByGameEntity[city.GUID];
this.approvalStatusByGameEntity.Remove(city.GUID);
}
this.SwapApprovalStatus(city, oldStatus, null);
}
this.RefreshApprovalStatus();
}
internal override void OnAssociationChanged(
CollectionChangeAction collectionChangeAction,
object entity)
{
if (this._suppressEvents)
{
return;
}
if (this._onAssociationChangedforObjectView != null)
{
this._onAssociationChangedforObjectView((object)this, new CollectionChangeEventArgs(collectionChangeAction, entity));
}
if (this._onAssociationChanged == null)
{
return;
}
this._onAssociationChanged((object)this, new CollectionChangeEventArgs(collectionChangeAction, entity));
}
private void DataBindings_CollectionChanged(object sender, CollectionChangeEventArgs e)
{
Binding binding = (Binding)e.Element;
CollectionChangeAction action = e.Action;
if (action != CollectionChangeAction.Add)
{
return;
}
if (binding.PropertyName == this.ExposedPropertyName)
{
binding.DataSourceNullValue = null;
(binding.DataSource as BindingSource).DataSourceChanged += delegate(object param0, EventArgs param1)
{
if (!this.checkBox.Checked)
{
this.pickerLauncherTextBox.SelectedValue = null;
}
this.pickerLauncherTextBox.UpdateDisplay();
};
}
}
public void CollectionChangingTest()
{
Control c = new Control();
c.BindingContext = new BindingContext();
c.CreateControl();
ControlBindingsCollection binding_coll = c.DataBindings;
Binding binding = new Binding("Text", new MockItem("A", 0), "Text");
Binding binding2 = new Binding("Name", new MockItem("B", 0), "Text");
binding_coll.Add(binding);
binding_coll.CollectionChanging += CollectionChangingHandler;
collection_expected_count = 1;
collection_action_expected = CollectionChangeAction.Add;
collection_element_expected = binding2;
collection_expected_assert = "#A0";
binding_coll.Add(binding2);
Assert.IsTrue(collection_changing_called, "#A1");
collection_changing_called = false;
collection_expected_count = 2;
collection_action_expected = CollectionChangeAction.Remove;
collection_element_expected = binding;
collection_expected_assert = "#B0";
binding_coll.Remove(binding);
Assert.IsTrue(collection_changing_called, "#B1");
collection_changing_called = false;
collection_expected_count = 1;
collection_element_expected = null;
collection_action_expected = CollectionChangeAction.Refresh;
collection_expected_assert = "#C0";
binding_coll.Clear();
Assert.IsTrue(collection_changing_called, "#C1");
}
public void CollectionChangingTest ()
{
Control c = new Control ();
c.BindingContext = new BindingContext ();
c.CreateControl ();
ControlBindingsCollection binding_coll = c.DataBindings;
Binding binding = new Binding ("Text", new MockItem ("A", 0), "Text");
Binding binding2 = new Binding ("Name", new MockItem ("B", 0), "Text");
binding_coll.Add (binding);
binding_coll.CollectionChanging += CollectionChangingHandler;
collection_expected_count = 1;
collection_action_expected = CollectionChangeAction.Add;
collection_element_expected = binding2;
collection_expected_assert = "#A0";
binding_coll.Add (binding2);
Assert.IsTrue (collection_changing_called, "#A1");
collection_changing_called = false;
collection_expected_count = 2;
collection_action_expected = CollectionChangeAction.Remove;
collection_element_expected = binding;
collection_expected_assert = "#B0";
binding_coll.Remove (binding);
Assert.IsTrue (collection_changing_called, "#B1");
collection_changing_called = false;
collection_expected_count = 1;
collection_element_expected = null;
collection_action_expected = CollectionChangeAction.Refresh;
collection_expected_assert = "#C0";
binding_coll.Clear ();
Assert.IsTrue (collection_changing_called, "#C1");
}
private void OptionsChanged(CollectionChangeAction action, CodeSwitchOption option)
{
if (action == CollectionChangeAction.Add)
{
option.SetTarget(_target);
}
else if (action == CollectionChangeAction.Remove)
{
option.SetTarget(null);
}
Refresh();
}
//private void OnEventHandler (object sender, EventArgs e)
//{
// eventhandled = true;
//}
private void OnCollectionEventHandler (object sender, CollectionChangeEventArgs e)
{
eventhandled = true;
Element = e.Element;
Action = e.Action;
times++;
}
private void ResetEventData ()
{
times = 0;
eventhandled = false;
Element = null;
Action = (CollectionChangeAction) 0;
}
private void OnCollectionChanged(
CollectionChangeAction action, object value)
{
for (int i = 0; i < Count; i++)
((GridColumn)List[i]).ColumnIndex = i;
InvalidateDisplayIndexes();
InvalidateLayout();
if (CollectionChanged != null)
{
CollectionChangeEventArgs e = new
CollectionChangeEventArgs(action, value);
CollectionChanged(this, e);
}
}
private void OnCollectionChanged_PreNotification(CollectionChangeAction cca,
int rowIndex,
int rowCount,
ref DataGridViewRow dataGridViewRow,
bool changeIsInsertion)
{
Debug.Assert(this.DataGridView != null);
bool useRowShortcut = false;
bool computeVisibleRows = false;
switch (cca)
{
case CollectionChangeAction.Add:
{
int firstDisplayedRowHeight = 0;
UpdateRowCaches(rowIndex, ref dataGridViewRow, true);
if ((GetRowState(rowIndex) & DataGridViewElementStates.Visible) == 0)
{
// Adding an invisible row - no need for repaint
useRowShortcut = true;
computeVisibleRows = changeIsInsertion;
}
else
{
int firstDisplayedRowIndex = this.DataGridView.FirstDisplayedRowIndex;
if (firstDisplayedRowIndex != -1)
{
firstDisplayedRowHeight = SharedRow(firstDisplayedRowIndex).GetHeight(firstDisplayedRowIndex);
}
}
if (changeIsInsertion)
{
this.DataGridView.OnInsertedRow_PreNotification(rowIndex, 1);
if (!useRowShortcut)
{
if ((GetRowState(rowIndex) & DataGridViewElementStates.Frozen) != 0)
{
// Inserted row is frozen
useRowShortcut = this.DataGridView.FirstDisplayedScrollingRowIndex == -1 &&
GetRowsHeightExceedLimit(DataGridViewElementStates.Visible, 0, rowIndex, this.DataGridView.LayoutInfo.Data.Height);
}
else if (this.DataGridView.FirstDisplayedScrollingRowIndex != -1 &&
rowIndex > this.DataGridView.FirstDisplayedScrollingRowIndex)
{
useRowShortcut = GetRowsHeightExceedLimit(DataGridViewElementStates.Visible, 0, rowIndex, this.DataGridView.LayoutInfo.Data.Height + this.DataGridView.VerticalScrollingOffset) &&
firstDisplayedRowHeight <= this.DataGridView.LayoutInfo.Data.Height;
}
}
}
else
{
this.DataGridView.OnAddedRow_PreNotification(rowIndex);
if (!useRowShortcut)
{
int displayedRowsHeightBeforeAddition = GetRowsHeight(DataGridViewElementStates.Visible) - this.DataGridView.VerticalScrollingOffset - dataGridViewRow.GetHeight(rowIndex);
dataGridViewRow = SharedRow(rowIndex);
useRowShortcut = this.DataGridView.LayoutInfo.Data.Height < displayedRowsHeightBeforeAddition &&
firstDisplayedRowHeight <= this.DataGridView.LayoutInfo.Data.Height;
}
}
break;
}
case CollectionChangeAction.Remove:
{
Debug.Assert(rowCount == 1);
DataGridViewElementStates rowStates = GetRowState(rowIndex);
bool deletedRowVisible = (rowStates & DataGridViewElementStates.Visible) != 0;
bool deletedRowFrozen = (rowStates & DataGridViewElementStates.Frozen) != 0;
// Can't do this earlier since it would break UpdateRowCaches
this.rowStates.RemoveAt(rowIndex);
this.SharedList.RemoveAt(rowIndex);
#if DEBUG
this.DataGridView.dataStoreAccessAllowed = false;
#endif
this.DataGridView.OnRemovedRow_PreNotification(rowIndex);
if (deletedRowVisible)
{
if (deletedRowFrozen)
{
// Delete row is frozen
useRowShortcut = this.DataGridView.FirstDisplayedScrollingRowIndex == -1 &&
GetRowsHeightExceedLimit(DataGridViewElementStates.Visible, 0, rowIndex, this.DataGridView.LayoutInfo.Data.Height + SystemInformation.HorizontalScrollBarHeight);
}
else if (this.DataGridView.FirstDisplayedScrollingRowIndex != -1 &&
rowIndex > this.DataGridView.FirstDisplayedScrollingRowIndex)
{
int firstDisplayedRowHeight = 0;
int firstDisplayedRowIndex = this.DataGridView.FirstDisplayedRowIndex;
if (firstDisplayedRowIndex != -1)
{
firstDisplayedRowHeight = SharedRow(firstDisplayedRowIndex).GetHeight(firstDisplayedRowIndex);
}
useRowShortcut = GetRowsHeightExceedLimit(DataGridViewElementStates.Visible, 0, rowIndex, this.DataGridView.LayoutInfo.Data.Height + this.DataGridView.VerticalScrollingOffset + SystemInformation.HorizontalScrollBarHeight) &&
firstDisplayedRowHeight <= this.DataGridView.LayoutInfo.Data.Height;
}
}
else
{
// Deleting an invisible row - no need for repaint
useRowShortcut = true;
}
break;
}
case CollectionChangeAction.Refresh:
{
InvalidateCachedRowCounts();
InvalidateCachedRowsHeights();
break;
}
default:
{
Debug.Fail("Unexpected cca value in DataGridViewRowCollecttion.OnCollectionChanged");
break;
}
}
this.DataGridView.ResetUIState(useRowShortcut, computeVisibleRows);
}
private void OnCollectionChanged_PostNotification(CollectionChangeAction cca, int rowIndex, int rowCount, DataGridViewRow dataGridViewRow, bool changeIsDeletion, bool changeIsInsertion, bool recreateNewRow, Point newCurrentCell)
{
if (changeIsDeletion)
{
this.DataGridView.OnRowsRemovedInternal(rowIndex, rowCount);
}
else
{
this.DataGridView.OnRowsAddedInternal(rowIndex, rowCount);
}
switch (cca)
{
case CollectionChangeAction.Add:
if (!changeIsInsertion)
{
this.DataGridView.OnAddedRow_PostNotification(rowIndex);
break;
}
this.DataGridView.OnInsertedRow_PostNotification(rowIndex, newCurrentCell, true);
break;
case CollectionChangeAction.Remove:
this.DataGridView.OnRemovedRow_PostNotification(dataGridViewRow, newCurrentCell);
break;
case CollectionChangeAction.Refresh:
if (changeIsDeletion)
{
this.DataGridView.OnClearedRows();
}
break;
}
this.DataGridView.OnRowCollectionChanged_PostNotification(recreateNewRow, newCurrentCell.X == -1, cca, dataGridViewRow, rowIndex);
}
/// <summary>
/// <para>Initializes a new instance of the <see cref='System.ComponentModel.CollectionChangeEventArgs'/> class.</para>
/// </summary>
public CollectionChangeEventArgs(CollectionChangeAction action, object element)
{
Action = action;
Element = element;
}
private void UpdateCollection (SWF.DataGridViewColumn column,
CollectionChangeAction change)
{
if (change == CollectionChangeAction.Remove) {
DataGridViewDataItemChildProvider child = columns [column];
RemoveChildProvider (child);
child.Terminate ();
columns.Remove (child.Column);
} else if (change == CollectionChangeAction.Add) {
DataGridViewDataItemChildProvider child;
if ((column as SWF.DataGridViewButtonColumn) != null)
child = new DataGridViewDataItemButtonProvider (this, column);
else if ((column as SWF.DataGridViewCheckBoxColumn) != null)
child = new DataGridViewDataItemCheckBoxProvider (this, column);
else if ((column as SWF.DataGridViewLinkColumn) != null)
child = new DataGridViewDataItemLinkProvider (this, column);
else if ((column as SWF.DataGridViewImageColumn) != null)
child = new DataGridViewDataItemImageProvider (this, column);
else if ((column as SWF.DataGridViewComboBoxColumn) != null)
child = new DataGridViewDataItemComboBoxProvider (this, column);
else
child = new DataGridViewDataItemEditProvider (this, column);
child.Initialize ();
AddChildProvider (child);
columns [child.Column] = child;
}
}
// Constructor.
public CollectionChangeEventArgs
(CollectionChangeAction action, Object element)
{
this.action = action;
this.element = element;
}
private CollectionChangeEventArgs CreateCollectionChangeEvent (CollectionChangeAction action)
{
return new CollectionChangeEventArgs (action, this);
}
private void StatementsChanged(CollectionChangeAction action, CodeStatement stmt, int index)
{
if (action == CollectionChangeAction.Add)
{
base.TrueStatements.Insert(index, stmt);
SetTargets(stmt, TargetPlaceholder, _target);
}
else if (action == CollectionChangeAction.Remove)
{
base.TrueStatements.Remove(stmt);
SetTargets(stmt, _target, TargetPlaceholder);
}
else
{
SetAllTargets(base.TrueStatements, _target, TargetPlaceholder);
base.TrueStatements.Clear();
}
}
internal void OnRowCollectionChanged_PostNotification(bool recreateNewRow,
bool allowSettingCurrentCell,
CollectionChangeAction cca,
DataGridViewRow dataGridViewRow,
int rowIndex)
{
if (recreateNewRow &&
cca == CollectionChangeAction.Refresh &&
this.Columns.Count != 0 &&
this.Rows.Count == 0 &&
this.AllowUserToAddRowsInternal)
{
AddNewRow(false);
}
if (cca == CollectionChangeAction.Refresh)
{
FlushSelectionChanged();
}
if ((cca == CollectionChangeAction.Refresh || cca == CollectionChangeAction.Add) &&
this.ptCurrentCell.X == -1 && allowSettingCurrentCell && !this.InSortOperation)
{
MakeFirstDisplayedCellCurrentCell(false /*includeNewRow*/);
}
if (this.AutoSize)
{
bool invalidatePreferredSizeCache = true;
switch (cca)
{
case CollectionChangeAction.Add:
Debug.Assert(rowIndex >= 0);
DataGridViewElementStates rowState = this.Rows.GetRowState(rowIndex);
invalidatePreferredSizeCache = ((rowState & DataGridViewElementStates.Visible) != 0);
break;
case CollectionChangeAction.Remove:
invalidatePreferredSizeCache = dataGridViewRow.DataGridView == null && dataGridViewRow.Visible;
break;
// case CollectionChangeAction.Refresh: invalidatePreferredSizeCache stays true
}
if (invalidatePreferredSizeCache)
{
LayoutTransaction.DoLayout(this.ParentInternal, this, PropertyNames.Rows);
}
}
}
private void CheckMessage(XenAPI.Message m, CollectionChangeAction a)
{
if (!m.ShowOnGraphs || m.cls != cls.VM)
return;
Host h = XenObject as Host;
if (h != null)
{
List<VM> resVMs = h.Connection.ResolveAll<VM>(h.resident_VMs);
foreach (VM v in resVMs)
{
if (v.uuid == m.obj_uuid)
{
if (a == CollectionChangeAction.Add)
DataEventList.AddEvent(new DataEvent(m.timestamp.ToLocalTime().Ticks, 0, m));
else
DataEventList.RemoveEvent(new DataEvent(m.timestamp.ToLocalTime().Ticks, 0, m));
break;
}
}
}
else if (XenObject is VM)
{
if (m.obj_uuid != Helpers.GetUuid(XenObject))
return;
if (a == CollectionChangeAction.Add)
DataEventList.AddEvent(new DataEvent(m.timestamp.ToLocalTime().Ticks, 0, m));
else
DataEventList.RemoveEvent(new DataEvent(m.timestamp.ToLocalTime().Ticks, 0, m));
}
}
private void OnPropertyChanged(string name, CollectionChangeAction action)
{
if (_PropertyChanged != null)
{
_PropertyChanged(this, new CollectionPropertyChangedEventArgs(name) { Action = action });
}
}
private void NotifyChanged(CollectionChangeAction action, CodeSwitchOption option)
{
if (_changed != null)
{
_changed(action, option);
}
}
private void UpdateCollection (SWF.DataGridViewColumn column,
CollectionChangeAction change)
{
if (change == CollectionChangeAction.Remove) {
DataGridViewHeaderItemProvider headerItem = headers [column];
RemoveChildProvider (headerItem);
headers.Remove (column);
} else if (change == CollectionChangeAction.Add) {
DataGridViewHeaderItemProvider headerItem
= new DataGridViewHeaderItemProvider (this, column);
headerItem.Initialize ();
AddChildProvider (headerItem);
headers [column] = headerItem;
}
}
private void OnCollectionChanged_PostNotification(CollectionChangeAction cca,
int rowIndex,
int rowCount,
DataGridViewRow dataGridViewRow,
bool changeIsDeletion,
bool changeIsInsertion,
bool recreateNewRow,
Point newCurrentCell)
{
Debug.Assert(this.DataGridView != null);
if (changeIsDeletion)
{
this.DataGridView.OnRowsRemovedInternal(rowIndex, rowCount);
}
else
{
this.DataGridView.OnRowsAddedInternal(rowIndex, rowCount);
}
#if DEBUG
this.DataGridView.dataStoreAccessAllowed = true;
#endif
switch (cca)
{
case CollectionChangeAction.Add:
{
if (changeIsInsertion)
{
this.DataGridView.OnInsertedRow_PostNotification(rowIndex, newCurrentCell, true);
}
else
{
this.DataGridView.OnAddedRow_PostNotification(rowIndex);
}
break;
}
case CollectionChangeAction.Remove:
{
this.DataGridView.OnRemovedRow_PostNotification(dataGridViewRow, newCurrentCell);
break;
}
case CollectionChangeAction.Refresh:
{
if (changeIsDeletion)
{
this.DataGridView.OnClearedRows();
}
break;
}
}
this.DataGridView.OnRowCollectionChanged_PostNotification(recreateNewRow, newCurrentCell.X == -1, cca, dataGridViewRow, rowIndex);
}
/// <summary>
/// Initializes a new instance of the ItemCollectionChangedEventArgs class.
/// </summary>
/// <param name="action">The type of action causing the change.</param>
/// <param name="item">The item that is the target of this event. This parameter will be null
/// if the collection is cleared.</param>
public ItemCollectionChangedEventArgs(CollectionChangeAction action, ImageListViewItem item)
{
Action = action;
Item = item;
}
private void OnCollectionChanged_PreNotification(CollectionChangeAction cca, int rowIndex, int rowCount, ref DataGridViewRow dataGridViewRow, bool changeIsInsertion)
{
int height;
bool useRowShortcut = false;
bool computeVisibleRows = false;
switch (cca)
{
case CollectionChangeAction.Add:
height = 0;
this.UpdateRowCaches(rowIndex, ref dataGridViewRow, true);
if ((this.GetRowState(rowIndex) & DataGridViewElementStates.Visible) != DataGridViewElementStates.None)
{
int firstDisplayedRowIndex = this.DataGridView.FirstDisplayedRowIndex;
if (firstDisplayedRowIndex != -1)
{
height = this.SharedRow(firstDisplayedRowIndex).GetHeight(firstDisplayedRowIndex);
}
break;
}
useRowShortcut = true;
computeVisibleRows = changeIsInsertion;
break;
case CollectionChangeAction.Remove:
{
DataGridViewElementStates rowState = this.GetRowState(rowIndex);
bool flag3 = (rowState & DataGridViewElementStates.Visible) != DataGridViewElementStates.None;
bool flag4 = (rowState & DataGridViewElementStates.Frozen) != DataGridViewElementStates.None;
this.rowStates.RemoveAt(rowIndex);
this.SharedList.RemoveAt(rowIndex);
this.DataGridView.OnRemovedRow_PreNotification(rowIndex);
if (!flag3)
{
useRowShortcut = true;
}
else if (!flag4)
{
if ((this.DataGridView.FirstDisplayedScrollingRowIndex != -1) && (rowIndex > this.DataGridView.FirstDisplayedScrollingRowIndex))
{
int num4 = 0;
int num5 = this.DataGridView.FirstDisplayedRowIndex;
if (num5 != -1)
{
num4 = this.SharedRow(num5).GetHeight(num5);
}
useRowShortcut = this.GetRowsHeightExceedLimit(DataGridViewElementStates.Visible, 0, rowIndex, (this.DataGridView.LayoutInfo.Data.Height + this.DataGridView.VerticalScrollingOffset) + SystemInformation.HorizontalScrollBarHeight) && (num4 <= this.DataGridView.LayoutInfo.Data.Height);
}
}
else
{
useRowShortcut = (this.DataGridView.FirstDisplayedScrollingRowIndex == -1) && this.GetRowsHeightExceedLimit(DataGridViewElementStates.Visible, 0, rowIndex, this.DataGridView.LayoutInfo.Data.Height + SystemInformation.HorizontalScrollBarHeight);
}
goto Label_02DF;
}
case CollectionChangeAction.Refresh:
this.InvalidateCachedRowCounts();
this.InvalidateCachedRowsHeights();
goto Label_02DF;
default:
goto Label_02DF;
}
if (changeIsInsertion)
{
this.DataGridView.OnInsertedRow_PreNotification(rowIndex, 1);
if (!useRowShortcut)
{
if ((this.GetRowState(rowIndex) & DataGridViewElementStates.Frozen) != DataGridViewElementStates.None)
{
useRowShortcut = (this.DataGridView.FirstDisplayedScrollingRowIndex == -1) && this.GetRowsHeightExceedLimit(DataGridViewElementStates.Visible, 0, rowIndex, this.DataGridView.LayoutInfo.Data.Height);
}
else if ((this.DataGridView.FirstDisplayedScrollingRowIndex != -1) && (rowIndex > this.DataGridView.FirstDisplayedScrollingRowIndex))
{
useRowShortcut = this.GetRowsHeightExceedLimit(DataGridViewElementStates.Visible, 0, rowIndex, this.DataGridView.LayoutInfo.Data.Height + this.DataGridView.VerticalScrollingOffset) && (height <= this.DataGridView.LayoutInfo.Data.Height);
}
}
}
else
{
this.DataGridView.OnAddedRow_PreNotification(rowIndex);
if (!useRowShortcut)
{
int num3 = (this.GetRowsHeight(DataGridViewElementStates.Visible) - this.DataGridView.VerticalScrollingOffset) - dataGridViewRow.GetHeight(rowIndex);
dataGridViewRow = this.SharedRow(rowIndex);
useRowShortcut = (this.DataGridView.LayoutInfo.Data.Height < num3) && (height <= this.DataGridView.LayoutInfo.Data.Height);
}
}
Label_02DF:
this.DataGridView.ResetUIState(useRowShortcut, computeVisibleRows);
}
public CollectionChangeEventArgs(CollectionChangeAction action, Object element)
{
}