// Emit the "ItemChanged" event.
protected virtual void OnItemChanged(ItemChangedEventArgs e)
{
if (ItemChanged != null)
{
ItemChanged(this, e);
}
}
/// <include file='doc\ListManager.uex' path='docs/doc[@for="CurrencyManager.OnItemChanged"]/*' />
/// <devdoc>
/// </devdoc>
protected virtual void OnItemChanged(ItemChangedEventArgs e)
{
// It is possible that CurrencyManager_PushData will change the position
// in the list. in that case we have to fire OnPositionChanged event
bool positionChanged = false;
// We should not push the data when we suspend the changeEvents.
// but we should still fire the OnItemChanged event that we get when processing the EndCurrentEdit method.
if ((e.Index == listposition || (e.Index == -1 && Position < Count)) && !inChangeRecordState)
{
positionChanged = CurrencyManager_PushData();
}
Debug.WriteLineIf(CompModSwitches.DataView.TraceVerbose, "OnItemChanged(" + e.Index.ToString(CultureInfo.InvariantCulture) + ") " + e.ToString());
try {
if (onItemChanged != null)
{
onItemChanged(this, e);
}
}
catch (Exception ex) {
OnDataError(ex);
}
if (positionChanged)
{
OnPositionChanged(EventArgs.Empty);
}
// onItemChangedCalled = true;
}
private void DataSource_Changed(object sender, ItemChangedEventArgs e)
{
if (this.DataGrid != null)
{
DataGrid.ParentRowsDataChanged();
}
}
private void DataSource_Changed(object sender, ItemChangedEventArgs e)
{
if ((this.DataGrid != null) && (this.ListManager.Position == e.Index))
{
this.DataGrid.InvalidateParentRows();
}
else if (this.DataGrid != null)
{
this.DataGrid.ParentRowsDataChanged();
}
}
protected virtual void OnItemChanged(ItemChangedEventArgs e)
{
if (ItemChanged != null)
{
ItemChanged(this, e);
}
transfering_data = true;
PushData();
transfering_data = false;
}
private void DataSource_Changed(object sender, ItemChangedEventArgs e)
{
if ((this.DataGrid != null) && (this.ListManager.Position == e.Index))
{
this.DataGrid.InvalidateParentRows();
}
else if (this.DataGrid != null)
{
this.DataGrid.ParentRowsDataChanged();
}
}
private void DataSource_Changed(object sender, ItemChangedEventArgs e)
{
if (DataGrid != null && ListManager.Position == e.Index)
{
DataGrid.InvalidateParentRows();
return;
}
if (DataGrid != null)
{
DataGrid.ParentRowsDataChanged();
}
}
private void DataManager_ItemChanged(object sender, ItemChangedEventArgs e) {
// Note this is being called internally with a null event.
if (dataManager != null) {
if (e.Index == -1) {
SetItemsCore(dataManager.List);
if (AllowSelection) {
this.SelectedIndex = this.dataManager.Position;
}
}
else {
SetItemCore(e.Index, dataManager[e.Index]);
}
}
}
private void DataManager_ItemChanged(object sender, ItemChangedEventArgs e)
{
if (this.dataManager != null)
{
if (e.Index == -1)
{
this.SetItemsCore(this.dataManager.List);
if (this.AllowSelection)
{
this.SelectedIndex = this.dataManager.Position;
}
}
else
{
this.SetItemCore(e.Index, this.dataManager[e.Index]);
}
}
}
private void OnItemChanged(object sender, ItemChangedEventArgs e)
{
/* if the list has changed, tell our subclass to re-bind */
if (e.Index == -1)
{
SetItemsCore(data_manager.List);
}
else
{
RefreshItem(e.Index);
}
/* For the first added item, ItemChanged is fired _after_ PositionChanged,
* so we need to set Index _only_ for that case - normally we would do that
* in PositionChanged handler */
if (AllowSelection && SelectedIndex == -1 && data_manager.Count == 1)
{
SelectedIndex = data_manager.Position;
}
}
/// <summary>
/// Handles changes to the tree's items collection
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void TreeItemsChangedEventHandler(object sender, ItemChangedEventArgs e)
{
switch (e.ChangeType)
{
case ItemChangeType.ItemAdded:
AddNode(_tree.Items[e.ItemIndex]);
break;
case ItemChangeType.ItemInserted:
InsertNode(e.ItemIndex, _tree.Items[e.ItemIndex]);
break;
case ItemChangeType.ItemChanged:
UpdateNode(e.ItemIndex, _tree.Items[e.ItemIndex]);
break;
case ItemChangeType.ItemRemoved:
RemoveNode(e.ItemIndex);
break;
case ItemChangeType.Reset:
BuildLevel();
break;
}
}
protected virtual void OnItemChanged(ItemChangedEventArgs e)
{
bool flag = false;
if (((e.Index == this.listposition) || ((e.Index == -1) && (this.Position < this.Count))) && !this.inChangeRecordState)
{
flag = this.CurrencyManager_PushData();
}
try
{
if (this.onItemChanged != null)
{
this.onItemChanged(this, e);
}
}
catch (Exception exception)
{
base.OnDataError(exception);
}
if (flag)
{
this.OnPositionChanged(EventArgs.Empty);
}
}
//=====================================================================
/// <summary>
/// This is called when the selected item in the data source changes
/// </summary>
/// <param name="sender">The sender of the event</param>
/// <param name="e">The event arguments</param>
private void DataManager_ItemChanged(object sender, ItemChangedEventArgs e)
{
DataManager_ItemChanged(sender, e.Index);
}
protected virtual void OnItemChanged (ItemChangedEventArgs e)
{
if (ItemChanged != null)
ItemChanged (this, e);
transfering_data = true;
PushData ();
transfering_data = false;
}
private void DataManager_ItemChanged(object sender, ItemChangedEventArgs e)
{
if (this.dataManager != null)
{
if (e.Index == -1)
{
this.SetItemsCore(this.dataManager.List);
if (this.AllowSelection)
{
this.SelectedIndex = this.dataManager.Position;
}
}
else
{
this.SetItemCore(e.Index, this.dataManager[e.Index]);
}
}
}
private void observable_ItemChanged(object sender, ItemChangedEventArgs<object> e)
{
sender.Cast<TimelineDocument>();
InvalidateTimelineControls();
}
private void OnListManagerItemChanged (object sender, ItemChangedEventArgs e)
{
// if it was us who created the new row in CurrentCell, ignore it and don't recreate the rows yet.
if (adding_new_row)
return;
if (e.Index == -1) {
ResetSelection ();
if (rows == null || RowsCount != rows.Length - (ShowEditRow ? 1 : 0))
{
if (is_editing)
CancelEditing ();
RecreateDataGridRows (true);
}
} else {
InvalidateRow (e.Index);
}
}
protected virtual void OnItemChanged(ItemChangedEventArgs e)
{
throw null;
}
private void DataSource_Changed(object sender, ItemChangedEventArgs e) {
if (this.DataGrid != null && this.ListManager.Position == e.Index) {
DataGrid.InvalidateParentRows();
return;
}
if (this.DataGrid != null)
DataGrid.ParentRowsDataChanged();
}
/// <include file='doc\ListManager.uex' path='docs/doc[@for="CurrencyManager.OnItemChanged"]/*' />
/// <devdoc>
/// </devdoc>
protected virtual void OnItemChanged(ItemChangedEventArgs e) {
// It is possible that CurrencyManager_PushData will change the position
// in the list. in that case we have to fire OnPositionChanged event
bool positionChanged = false;
// We should not push the data when we suspend the changeEvents.
// but we should still fire the OnItemChanged event that we get when processing the EndCurrentEdit method.
if ((e.Index == listposition || (e.Index == -1 && Position < Count)) && !inChangeRecordState)
positionChanged = CurrencyManager_PushData();
Debug.WriteLineIf(CompModSwitches.DataView.TraceVerbose, "OnItemChanged(" + e.Index.ToString(CultureInfo.InvariantCulture) + ") " + e.ToString());
try {
if (onItemChanged != null)
onItemChanged(this, e);
}
catch (Exception ex) {
OnDataError(ex);
}
if (positionChanged)
OnPositionChanged(EventArgs.Empty);
// onItemChangedCalled = true;
}
private void list_ItemChanged(object sender, ItemChangedEventArgs<object> e)
{
if (m_inTransaction)
m_itemsChanged.Add(e.Item);
else
OnItemChanged(e.Item);
}
// Emit the "ItemChanged" event.
protected virtual void OnItemChanged(ItemChangedEventArgs e)
{
if(ItemChanged != null)
{
ItemChanged(this, e);
}
}
private void DataManager_ItemChanged(object sender, ItemChangedEventArgs e)
{
if (_dataManager != null)
{
if (e.Index == -1)
{
this.Items.Clear();
this.Items.AddRange(_dataManager.List);
this.SelectedIndex = _dataManager.Position;
}
else
{
this.Items[e.Index] = _dataManager.List[e.Index];
}
this.OnSelectedValueChanged(EventArgs.Empty);
}
}
void list_manager_item_changed (object sender, ItemChangedEventArgs e)
{
Console.WriteLine ("list manager item changed (index = {0})", e.Index);
Console.WriteLine (Environment.StackTrace);
}
private void ErrorManager_ItemChanged(object sender, ItemChangedEventArgs e)
{
BindingsCollection bindings = this.errorManager.Bindings;
int count = bindings.Count;
if ((e.Index == -1) && (this.errorManager.Count == 0))
{
for (int i = 0; i < count; i++)
{
if (bindings[i].Control != null)
{
this.SetError(bindings[i].Control, "");
}
}
}
else
{
this.ErrorManager_CurrentChanged(sender, e);
}
}
private void DataManager_ItemChanged(object sender, ItemChangedEventArgs e)
{
if (_Parent is Control)
{
Control parentControl = (Control)_Parent;
if (parentControl.InvokeRequired)
{
parentControl.Invoke(new ItemChangedEventHandler(DataManager_ItemChanged), sender, e);
return;
}
}
if (_DataManager != null)
{
if (e == null || e.Index == -1)
{
this.SetItemsCore(_DataManager.List);
if (_Parent.AllowSelection)
{
_Parent.SelectedIndex = _DataManager.Position;
}
}
else
{
this.SetItemCore(e.Index, _DataManager.List[e.Index]);
}
}
}
/// <summary>
/// Extends BeginInvoke so that when a state object is not needed, null does not need to be passed.
/// <example>
/// itemchangedeventhandler.BeginInvoke(sender, e, callback);
/// </example>
/// </summary>
public static IAsyncResult BeginInvoke(this ItemChangedEventHandler itemchangedeventhandler, Object sender, ItemChangedEventArgs e, AsyncCallback callback)
{
if(itemchangedeventhandler == null) throw new ArgumentNullException("itemchangedeventhandler");
return itemchangedeventhandler.BeginInvoke(sender, e, callback, null);
}
private void OnItemChanged (object sender, ItemChangedEventArgs e)
{
/* if the list has changed, tell our subclass to re-bind */
if (e.Index == -1)
SetItemsCore (data_manager.List);
else
RefreshItem (e.Index);
/* For the first added item, ItemChanged is fired _after_ PositionChanged,
* so we need to set Index _only_ for that case - normally we would do that
* in PositionChanged handler */
if (AllowSelection && SelectedIndex == -1 && data_manager.Count == 1)
SelectedIndex = data_manager.Position;
}
private void tree_ItemChanged(object sender, ItemChangedEventArgs<object> e)
{
object tree = e.Item;
IEnumerable<TreeControl.Node> nodes = m_itemToNodeMap[tree];
foreach (TreeControl.Node node in nodes)
{
if (e.Reloaded)
RefreshNode(node);
else
UpdateNode(node);
}
}
private void DataManager_ItemChanged(object sender, ItemChangedEventArgs e)
{
if (this.InvokeRequired)
{
this.Invoke(new ItemChangedEventHandler(DataManager_ItemChanged), sender, e);
return;
}
if (_DataManager != null)
{
if (e==null || e.Index == -1)
{
this.SetItemsCore(_DataManager.List);
if (this.AllowSelection)
{
if (_DataManager.Position == -1)
this.SelectedNode = null;
else
this.SelectedNode = _AdvTree.FindNodeByBindingIndex(_DataManager.Position);
}
}
else
{
this.SetItemCore(e.Index, _DataManager.List[e.Index]);
}
}
}
protected void ItemChanged (object sender, ItemChangedEventArgs args)
{
//Console.WriteLine (Environment.StackTrace);
event_log += String.Format ("{0}: ItemChanged (index = {1})\n", event_num++, args.Index);
}
private void ErrorManager_ItemChanged(object sender, ItemChangedEventArgs e) {
BindingsCollection errBindings = errorManager.Bindings;
int bindingsCount = errBindings.Count;
// If the list became empty then reset the errors
if (e.Index == -1 && errorManager.Count == 0) {
for (int j = 0; j < bindingsCount; j++) {
if (errBindings[j].Control != null) {
// ...ignore everything but bindings to Controls
SetError(errBindings[j].Control, "");
}
}
}
else {
ErrorManager_CurrentChanged(sender, e);
}
}
private void observableContext_ItemChanged(object sender, ItemChangedEventArgs<object> e)
{
Invalidate();
}
private void OnColumnsChanged(object sender, ItemChangedEventArgs e)
{
this.Table = this.Table;
}
// protected override void OnSelectedIndexChanged(EventArgs e)
// {
// base.OnSelectedIndexChanged (e);
//
// // Did this originate from us, or was this caused by the
// // CurrencyManager in the first place. If we're sure it was us,
// // and there is actually a selected item (this event is also raised
// // when transitioning to the 'no items selected' state), and we
// // definitely do have a CurrencyManager (i.e. we are actually bound
// // to a data source), then we notify the CurrencyManager.
//
// if (!m_changingIndex && this.SelectedIndex > 0 && m_currencyManager != null)
// {
// m_currencyManager.Position = this.SelectedIndex;
// }
// }
private void currencyManager_ItemChanged(object sender, ItemChangedEventArgs e)
{
// An index of -1 seems to be the indication that lots has
// changed. (I've not found where it says this in the
// documentation - I got this information from a comment in Mark
// Boulter's code.) So we always reload all items from the
// source when this happens.
if (e.Index == -1)
{
// ...but before we reload all items from source, we also look
// to see if the list we're supposed to bind to has changed
// since last time, and if it has, reattach our event handlers.
if (!m_bindingList.Equals(m_currencyManager.List))
{
m_bindingList.ListChanged -=
new ListChangedEventHandler(bindingList_ListChanged);
m_bindingList = m_currencyManager.List as IBindingList;
if (m_bindingList != null)
{
m_bindingList.ListChanged +=
new ListChangedEventHandler(bindingList_ListChanged);
}
}
LoadItemsFromSource();
}
}
private void DataManager_ItemChanged(object sender, ItemChangedEventArgs e) {
// Note this is being called internally with a null event.
if (dataManager != null) {
if (e.Index == -1) {
SetItemsCore(dataManager.List);
if (AllowSelection) {
this.SelectedIndex = this.dataManager.Position;
}
}
else {
SetItemCore(e.Index, dataManager[e.Index]);
}
}
}
/// <summary>
/// Performs custom actions on ItemChanged events</summary>
/// <param name="sender">Sender</param>
/// <param name="e">Event args</param>
void ObservableContextItemChanged(object sender, ItemChangedEventArgs<object> e)
{
m_curveItemChanged = e.Item.Is<ICurve>() || e.Item.Is<IControlPoint>();
}
private void observableContext_ItemChanged(object sender, ItemChangedEventArgs<object> e)
{
Invalidate();
RefreshEditingControls();
}
private void context_ObjectChanged(object sender, ItemChangedEventArgs<object> e)
{
Invalidate();
}
/// <summary>
/// Performs custom actions on ItemChanged events</summary>
/// <param name="sender">Sender</param>
/// <param name="e">Item changed event args</param>
void observableContext_ItemChanged(object sender, ItemChangedEventArgs<object> e)
{
ItemControl itemControl;
if (m_itemControls.TryGetValue(e.Item, out itemControl))
OnItemChanged(e.Item);
}
private void CurrencyManager_ItemChanged(object sender, System.Windows.Forms.ItemChangedEventArgs e)
{
CurrencyManager myCurrencyManager = (CurrencyManager)sender;
Console.WriteLine("Item Changed " + myCurrencyManager.Position);
}
void CurrencyManager_ItemChanged (object sender, ItemChangedEventArgs args)
{
Console.WriteLine ("ItemChanged ({0})\n{1}", args.Index, Environment.StackTrace);
}
