protected override void HandleBranchChanged(object sender, ItemChangedEventArgs <Service> e)
{
switch (e.Name)
{
case SingleBranchNames.Begin:
case SingleBranchNames.Content:
case SingleBranchNames.Continue:
case SingleBranchNames.Data:
case SingleBranchNames.Http:
case SingleBranchNames.Init:
case SingleBranchNames.Next:
case SingleBranchNames.Offload:
case SingleBranchNames.Proceed:
case SingleBranchNames.Request:
case SingleBranchNames.Source:
case SingleBranchNames.Subject:
Secretary.Report(5, "using deprecated single branch at", ConfigLine);
this.withBranch = e.NewValue;
break;
case SingleBranchNames.With:
this.withBranch = e.NewValue;
break;
default:
break;
}
}
private void OnItemStateChanged(Object sender, ItemChangedEventArgs e)
{
if (!_allowToSave)
{
return;
}
var itemInfo = e.ItemInfo;
if (e.Checked)
{
var itemControl = new ItemControl(itemInfo, this);
xtraTabControl.TabPages.Add(itemControl);
itemControl.LoadData();
}
else
{
var itemControl = xtraTabControl.TabPages
.OfType <ItemControl>()
.FirstOrDefault(control =>
String.Equals(control.ItemInfo.Id, itemInfo.Id, StringComparison.OrdinalIgnoreCase));
if (itemControl != null)
{
SlideContainer.EditedContent.ApproachState.TabA.Items.RemoveAll(item =>
String.Equals(item.Id, itemControl.ItemInfo.Id, StringComparison.OrdinalIgnoreCase));
xtraTabControl.TabPages.Remove(itemControl);
}
}
SlideContainer.RaiseSlideTypeChanged();
RaiseEditValueChanged();
}
private void TableDataChangedEventHandler(object sender, ItemChangedEventArgs e)
{
switch (e.ChangeType)
{
case ItemChangeType.ItemAdded:
NotifyListChanged(new ListChangedEventArgs(ListChangedType.ItemAdded, e.ItemIndex));
break;
case ItemChangeType.ItemChanged:
NotifyListChanged(new ListChangedEventArgs(ListChangedType.ItemChanged, e.ItemIndex));
break;
case ItemChangeType.ItemRemoved:
NotifyListChanged(new ListChangedEventArgs(ListChangedType.ItemDeleted, e.ItemIndex));
break;
case ItemChangeType.ItemInserted:
case ItemChangeType.Reset:
NotifyListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));
break;
default:
throw new NotImplementedException();
}
}
private void AllowedProcesses_ItemChanged(object sender, ItemChangedEventArgs <AllowedProcess> e)
{
if (e.PropertyName != nameof(AllowedProcess.Dirty))
{
ProcessListDirty = true;
}
}
private void TableStructureChangedEventHandler(object sender, ItemChangedEventArgs e)
{
ITableColumn column = e.ItemIndex >= 0 ? (ITableColumn)_table.Columns[e.ItemIndex] : null;
switch (e.ChangeType)
{
case ItemChangeType.ItemAdded:
_columnToPropertyMap[column] = new TableDataPropertyDescriptor(this, column);
NotifyListChanged(new ListChangedEventArgs(ListChangedType.PropertyDescriptorAdded, -1));
break;
case ItemChangeType.ItemChanged:
_columnToPropertyMap[column] = new TableDataPropertyDescriptor(this, column);
NotifyListChanged(new ListChangedEventArgs(ListChangedType.PropertyDescriptorChanged, -1));
break;
case ItemChangeType.ItemRemoved:
_columnToPropertyMap.Remove(column);
NotifyListChanged(new ListChangedEventArgs(ListChangedType.PropertyDescriptorDeleted, -1));
break;
case ItemChangeType.ItemInserted:
case ItemChangeType.Reset:
_columnToPropertyMap.Clear();
NotifyListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));
break;
}
}
static void OnItemChanged(Object sender, ItemChangedEventArgs e)
{
PotPotPlayer modPlayer = Main.LocalPlayer.GetModPlayer <PotPotPlayer>();
modPlayer.PotPotContent.Remove(e.Old);
modPlayer.PotPotContent.Add(e.New);
}
void RPMs_ItemChangedCustomSender(object sender, ItemChangedEventArgs e)
{
switch (sender.ToString())
{
case "RPMs":
ChangedFlag_RPMs = true;
break;
case "Injection":
ChangedFlag_Injection = true;
break;
default:
var tu = sender as Tulpe <String, int>;
switch (tu.Item1)
{
case "DataLockStatus":
TryAddChanged("DataLockStatus", tu.Item2);
break;
case "GasCurve":
TryAddChanged("GasCurve", tu.Item2);
break;
case "MAPValues":
TryAddChanged("MAPValues", tu.Item2);
break;
case "PetrolCurve":
TryAddChanged("PetrolCurve", tu.Item2);
break;
}
break;
}
}
// 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();
}
}
protected override void HandleBranchChanged(object sender, ItemChangedEventArgs <Service> e)
{
if (e.Name == "iterator")
{
this.Iterator = e.NewValue;
}
}
/// <summary>
/// Método que se ejecuta cuando se dispara el evento PropertyChanged de un elemento.
/// Este método, lanza el evento ItemPropertyChanged, enviando como argumentos el elemento de la
/// colección en el que ha cambiado alguna propiedad y el nombre de la propiedad.
/// </summary>
private void ChildPropertyChanged(object sender, PropertyChangedEventArgs e)
{
T typedSender = (T)sender;
var args = new ItemChangedEventArgs <T>(typedSender, e.PropertyName);
ItemPropertyChanged?.Invoke(this, args);
}
protected override void HandleBranchChanged(object sender, ItemChangedEventArgs <Service> e)
{
if (e.Name == "successful")
{
successful = e.NewValue;
}
}
protected override void HandleBranchChanged(object sender, ItemChangedEventArgs <Service> e)
{
if (e.Name == "mapped")
{
this.Mapped = e.NewValue ?? Stub;
}
}
private void RepositoryEmployeeChanged(object sender, ItemChangedEventArgs <Employee> e)
{
if (e.Item.Person.Id != Model.Id)
{
return;
}
if (e.Action == ItemChangedEventArgs <Employee> .ActionType.Add)
{
Employees.Add(e.Item);
}
if (e.Action == ItemChangedEventArgs <Employee> .ActionType.Remove)
{
var emploee = Employees.FirstOrDefault(x => x.Organization.Id == e.Item.Organization.Id);
if (emploee != null)
{
Employees.Remove(emploee);
}
}
if (e.Action == ItemChangedEventArgs <Employee> .ActionType.Update)
{
var emploee = Employees.FirstOrDefault(x => x.Organization.Id == e.Item.Organization.Id);
if (emploee != null)
{
Employees.Remove(emploee);
}
Employees.Add(e.Item);
}
}
protected virtual void OnItemChanged(ItemChangedEventArgs <object> e)
{
if (ItemChanged != null)
{
ItemChanged(this, e);
}
}
protected override void HandleBranchChanged(object sender, ItemChangedEventArgs <Service> e)
{
if (e.Name == "line")
{
this.IncomingLineService = e.NewValue;
}
}
private void CurrencyManager_ItemChanged(object sender, ItemChangedEventArgs e)
{
if (e.Index > -1)
{
DataBind();
}
}
private void OnItemsChanged(object sender, ItemChangedEventArgs e)
{
if (e.ChangeType == ItemChangeType.ItemChanged)
{
this.UpdateEnabled();
}
}
void OnItemChanged(ItemChangedEventArgs <PendingChange> e)
{
if (ItemChanged != null)
{
ItemChanged(this, e);
}
}
/// <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;
}
}
private void CurrencyManager_ItemChanged(object sender, ItemChangedEventArgs e)
{
if (e.Index > -1)
{
((BindableTreeNode)Nodes[e.Index]).DataBind();
}
}
protected override void HandleBranchChanged(object sender, ItemChangedEventArgs <Service> e)
{
if (e.Name == "default")
{
defaultBranch = e.NewValue ?? Stub;
}
}
public void Constructor()
{
ItemChangedEventArgs args;
args = new ItemChangedEventArgs("new", "previous", ItemQuality.Good, ItemQuality.Good);
Assert.IsType <ItemChangedEventArgs>(args);
}
protected override void HandleBranchChanged(object sender, ItemChangedEventArgs <Service> e)
{
base.HandleBranchChanged(sender, e);
if (e.Name == "meanwhile")
{
this.Meanwhile = e.NewValue ?? Stub;
}
}
public void Properties()
{
ItemChangedEventArgs args = new ItemChangedEventArgs("new", "previous", ItemQuality.Good, ItemQuality.Good);
Assert.Equal("previous", args.PreviousValue);
Assert.Equal("new", args.Value);
Assert.Equal(false, args.QualityChanged);
}
private void Bookmarks_ItemChanged(object sender, ItemChangedEventArgs <BookmarkViewModel> e)
{
int pageNumber = Math.Min(e.Item.PageNumber, this.document.Pages.Count);
pageNumber = Math.Max(1, pageNumber);
e.Item.PageNumber = pageNumber;
}
void ItemChanged(object sender, ItemChangedEventArgs args)
{
item_changed = ++event_num;
item_changed_args = args;
Console.WriteLine("item_changed = {0}, index = {1}", item_changed, args.Index);
//Console.WriteLine (Environment.StackTrace);
event_log += String.Format("{0}: ItemChanged (index = {1})\n", item_changed, args.Index);
}
private void TasksOnItemChanged(object sender, ItemChangedEventArgs <TaskItemViewmodel> itemChangedEventArgs)
{
if (itemChangedEventArgs.Item.HasChanges)
{
HasChanges = true;
UpdateBottom();
}
}
private void Pending_ItemChanged(object sender, ItemChangedEventArgs <ToDoItem> e)
{
var item = e.ChangedItem;
_db.Todo.UpdateToDoItem(item);
Pending.UpdateCollection(_db.Todo.GetUncompleted());
Completed.UpdateCollection(_db.Todo.GetCompleteded());
}
private void OnItemChangedEventHandler(ItemChangedEventArgs e)
{
EventHandler <ItemChangedEventArgs> handler = ItemChanged;
if (handler != null)
{
handler(this, e);
}
}
private void RepositoryOrganizationChanged(object sender, ItemChangedEventArgs <Organization> e)
{
if (e.Action == ItemChangedEventArgs <Organization> .ActionType.Add)
{
var organization = new OrganizationViewModel(e.Item);
Organizations.Add(organization);
SelectedOrganization = organization;
}
}
// 将Edit控件中的文字内容兑现到Visual视图上
// 不负责修改屏幕图像
internal void EditControlTextToVisual()
{
if (this.m_curText != null)
{
string strOldValue = this.m_curText.Text;
if (this.m_curText.Text != this.curEdit.Text)
{
this.m_curText.Text = this.curEdit.Text;
Item item = this.m_curText.GetItem();
if (item != this.m_selectedItem)
{
Debug.Assert(false,"当前Text对应的Item与SelectedItem不一致");
throw(new Exception("当前Text对应的Item与SelectedItem不一致"));
}
if (this.m_selectedItem is ElementItem)
{
ElementItem element = (ElementItem)this.m_selectedItem;
if (this.m_curText.Name == "attributes")
element.m_xmlAttrsTimestamp ++;
if (this.m_curText.Name == "content")
element.m_xmlChildrenTimestamp ++;
element.Flush();
}
if (this.m_selectedItem is AttrItem)
{
// 触发事件
////////////////////////////////////////////////////
// ItemAttrChanged
////////////////////////////////////////////////////
ItemChangedEventArgs args =
new ItemChangedEventArgs();
args.item = this.m_selectedItem;
args.NewValue = this.m_curText.Text;
args.OldValue = strOldValue;
this.fireItemChanged(this,args);
}
// 文档发生变化
this.FireTextChanged();
}
}
}
private void observableContext_ItemChanged(object sender, ItemChangedEventArgs<object> e)
{
InvalidateVisual();
RefreshEditingControls();
}
private void OnChildrenSetItemChanged(object sender, ItemChangedEventArgs<Department> e)
{
var childDepartment = e.Item;
if (e.Type == ItemChangedType.Added)
{
if (childDepartment.Parent != null)
{
childDepartment.Parent.ChildrenDepartment.Remove(childDepartment);
}
childDepartment.Parent = this;
}
else
{
childDepartment.Parent = null;
}
}
/// <summary>
/// Called when an entity is changed.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The e.</param>
private void OnEntityChanged(ItemChangedEventArgs<Entity> e)
{
this.ResetCommand.RaiseCanExecuteChanged();
this.SelectAllCommand.RaiseCanExecuteChanged();
}
private void method_1(object sender, ItemChangedEventArgs<RuleCategory> e)
{
this.method_2();
}
void m_observableContext_ItemChanged(object sender, ItemChangedEventArgs<object> e)
{
UpdateTerrainControl(e.Item);
}
// 设置一个属性节点的值
// 如果指定的属性不存在，则新创建属性
public void SetAttrValue(string strAttrName,
string strNewAttrValue)
{
if (strNewAttrValue == null)
strNewAttrValue = "";
AttrItem attr = this.GetAttrItem(strAttrName);
if (attr == null)
{
attr = this.m_document.CreateAttrItem(strAttrName);
attr.SetValue(strNewAttrValue);
this.AppendAttrInternal(attr,true,false);
}
else
{
string strOldValue = attr.GetValue();
// 修改值
if (strOldValue != strNewAttrValue)
{
// 需要改
attr.SetValue(strNewAttrValue);
this.m_objAttrsTimestamp ++;
// 触发事件
////////////////////////////////////////////////////
// ItemAttrChanged
////////////////////////////////////////////////////
ItemChangedEventArgs args =
new ItemChangedEventArgs();
args.item = attr;
args.NewValue = strNewAttrValue;
args.OldValue = strOldValue;
this.m_document.fireItemChanged(this.m_document,args);
}
}
this.AfterAttrCreateOrChange(attr);
}
private void SortDescriptors_ItemChanged(object sender, ItemChangedEventArgs<SortDescriptor> e) {
// todo - should relationship be 2-way? should changes to views sortdescriptions
// echo back to our SortDescriptors????
// note with a grid that the view's SDs are what change automatically ...
RefreshViewAfterSortChange();
}
private void tree_ItemChanged(object sender, ItemChangedEventArgs<object> e)
{
foreach (var node in m_itemToNodesMap[e.Item])
{
UpdateNode(node);
}
}
/// <summary>
/// Raise the ItemChanged event</summary>
/// <param name="e">Event args</param>
protected virtual void OnObjectChanged(ItemChangedEventArgs<object> e)
{
ItemChanged.Raise(this, e);
}
private void GroupDescriptors_ItemChanged(object sender, ItemChangedEventArgs<GroupDescriptor> e) {
RefreshViewAfterGroupChange();
}
private void TableDataChangedEventHandler(object sender, ItemChangedEventArgs e)
{
switch (e.ChangeType)
{
case ItemChangeType.ItemAdded:
NotifyListChanged(new ListChangedEventArgs(ListChangedType.ItemAdded, e.ItemIndex));
break;
case ItemChangeType.ItemChanged:
NotifyListChanged(new ListChangedEventArgs(ListChangedType.ItemChanged, e.ItemIndex));
break;
case ItemChangeType.ItemRemoved:
NotifyListChanged(new ListChangedEventArgs(ListChangedType.ItemDeleted, e.ItemIndex));
break;
case ItemChangeType.ItemInserted:
case ItemChangeType.Reset:
NotifyListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));
break;
default:
throw new NotImplementedException();
}
}
private void TableStructureChangedEventHandler(object sender, ItemChangedEventArgs e)
{
ITableColumn column = e.ItemIndex >= 0 ? (ITableColumn)_table.Columns[e.ItemIndex] : null;
switch (e.ChangeType)
{
case ItemChangeType.ItemAdded:
_columnToPropertyMap[column] = new TableDataPropertyDescriptor(this, column);
NotifyListChanged(new ListChangedEventArgs(ListChangedType.PropertyDescriptorAdded, -1));
break;
case ItemChangeType.ItemChanged:
_columnToPropertyMap[column] = new TableDataPropertyDescriptor(this, column);
NotifyListChanged(new ListChangedEventArgs(ListChangedType.PropertyDescriptorChanged, -1));
break;
case ItemChangeType.ItemRemoved:
_columnToPropertyMap.Remove(column);
NotifyListChanged(new ListChangedEventArgs(ListChangedType.PropertyDescriptorDeleted, -1));
break;
case ItemChangeType.ItemInserted:
case ItemChangeType.Reset:
_columnToPropertyMap.Clear();
NotifyListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));
break;
}
}
private void observableContext_ItemChanged(object sender, ItemChangedEventArgs<object> e)
{
Invalidate();
}
private void method_0(object sender, ItemChangedEventArgs<Rule> e)
{
this.method_2();
}
private void FilterDescriptors_ItemChanged(object sender, ItemChangedEventArgs<FilterDescriptor> e) {
RefreshViewAfterFilterChange();
}
public void fireItemChanged(object sender,
ItemChangedEventArgs args)
{
if (ItemChanged != null)
{
ItemChanged(sender,args);
}
}
/// <summary>
/// Handles the ItemChanged event of the environment variable collection.
/// </summary>
/// <param name = "sender">The source of the event.</param>
/// <param name = "e">The <see cref = "AirCannon.Framework.Models.ItemChangedEventArgs<AirCannon.Framework.Models.EnvironmentVariable>" /> instance containing the event data.</param>
private void _HandleEnvironmentVariableChanged(object sender, ItemChangedEventArgs<EnvironmentVariable> e)
{
HasChanges = true;
}
private void OnPersonSetItemChanged(object sender, ItemChangedEventArgs<Person> e)
{
var person = e.Item;
if (e.Type == ItemChangedType.Added)
{
if (person.Department != null)
{
person.Department.Persons.Remove(person);
}
person.Department = this;
}
else
{
person.Department = null;
}
}
private void HandlerItemChanged(object sender, ItemChangedEventArgs e)
{
BindingsCollection bc = _errorManager.Bindings;
if (e.Index != -1 || _errorManager.Count != 0)
{
HandlerCurrentChanged(sender, e);
}
else
{
int count = bc.Count;
for (int i = 0; i < count; i++)
{
if (bc[i].Control != null)
{
SetError(bc[i].Control, string.Empty);
}
}
}
}
private void OnItemChanged(object sender, ItemChangedEventArgs<IFeatureItem> e)
{
this.OnPropertyChanged(nameof(IsDefaultSelected));
}
private void m_observableContext_ItemChanged(object sender, ItemChangedEventArgs<object> e)
{
ObservableContextChanged(e.Item);
}
private void tree_ItemChanged(object sender, ItemChangedEventArgs<object> e)
{
if (e.Reloaded)
{
if (m_itemsToReload != null)
m_itemsToReload.Add(e.Item);
else
{
foreach (var node in m_itemToNodesMap[e.Item])
RefreshNode(node);
}
return;
}
foreach (var node in m_itemToNodesMap[e.Item])
{
UpdateNode(node);
}
}
private void tree_ItemChanged(object sender, ItemChangedEventArgs<object> e)
{
Node node;
if (m_itemToNodeMap.TryGetValue(e.Item, out node))
{
UpdateNode(m_itemToNodeMap[e.Item]);
}
}
