// 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); }