/// <summary> /// Wires an event handler to fire when the property of the dataItem is changed /// </summary> /// <param name="dataItem">object to detect changes on</param> /// <param name="handler">handler to fire when the property changes on the specified dataItem</param> /// <returns>binding reference used to track the event hookup, to pass to <see cref="RemoveValueChangedHandler"/> when removing the handler</returns> public override object AddValueChangedHandler(object dataItem, EventHandler <EventArgs> handler) { if (dataItem == null) { return(false); } var notify = dataItem as INotifyPropertyChanged; if (notify != null) { var helper = new ValueChangedHandler { Binding = this, DataItem = dataItem, Handler = handler }; notify.PropertyChanged += helper.HandlePropertyChanged; return(helper); } else { var type = dataItem.GetType(); var changedEvent = type.GetEvent(Property + "Changed"); if (changedEvent != null) { changedEvent.AddEventHandler(dataItem, handler); } return(dataItem); } }
/// <summary> /// Wires an event handler to fire when the property of the dataItem is changed /// </summary> /// <param name="dataItem">object to detect changes on</param> /// <param name="handler">handler to fire when the property changes on the specified dataItem</param> /// <returns>binding reference used to track the event hookup, to pass to <see cref="RemoveValueChangedHandler"/> when removing the handler</returns> public override object AddValueChangedHandler(object dataItem, EventHandler <EventArgs> handler) { #if WINRT throw new NotImplementedException(); #else if (dataItem == null) { return(false); } var notify = dataItem as INotifyPropertyChanged; if (notify != null) { var helper = new ValueChangedHandler { Binding = this, DataItem = dataItem, Handler = handler }; notify.PropertyChanged += helper.HandlePropertyChanged; return(helper); } else { var type = dataItem.GetType(); var changedEvent = type.GetEvent(Property + "Changed"); if (changedEvent != null) { try { changedEvent.AddEventHandler(dataItem, handler); } catch {} } return(dataItem); } #endif }
private static void RaiseValueChanged(IntPtr cPtr, float oldValue, float newValue) { try { if (!_ValueChanged.ContainsKey(cPtr)) { throw new InvalidOperationException("Delegate not registered for ValueChanged event"); } if (oldValue == -1234.5678f && newValue == -1234.5678f) { _ValueChanged.Remove(cPtr); return; } if (Noesis.Extend.Initialized) { ValueChangedHandler handler = _ValueChanged[cPtr]; if (handler != null) { handler(oldValue, newValue); } } } catch (Exception exception) { Noesis.Error.SetNativePendingError(exception); } }
public static MenuItem AddMItem <T>(this Menu menu, string name, T value, ValueChangedHandler <T> handler, string internalName = "") { var menuItem = new MenuItem(string.IsNullOrEmpty(internalName) ? GetValidName(menu, name) : internalName, name).SetValue(GetValidValue(value)); menuItem.ValueChanged += (sender, args) => handler(args.GetNewValue <T>()); handler(menuItem.GetValue <T>()); return(menu.AddItem(menuItem)); }
private void OnTaskCanceled(IBackgroundTaskInstance sender, BackgroundTaskCancellationReason reason) { Debug.WriteLine($"Cancellation, reason: {reason}."); ValueChanged -= BroadcastReceivedMessage; if (_deferral != null) { _deferral.Complete(); } }
public static void SafeSendEvent(ValueChangedHandler handler, object sender, double oldValue, double newValue) { var tmp = handler; if (tmp != null) { tmp(sender, oldValue, newValue); } }
protected virtual void OnValueChanged(ValueChangedEventArgs e) { ValueChangedHandler handler = ValueChanged; if (handler != null) { handler(this, e); } }
protected virtual void OnValueChanged(uint value) { ValueChangedHandler handler = ValueChanged; if (handler != null) { handler(this, value); } }
public void SetValueChangedEventHandler() { if (addViewPage == null) { return; } ValueChanged += new ValueChangedHandler(addViewPage.ValueChanged); IncorrectValueSpecified += new IncorrectValueSpecifiedHandler(addViewPage.IncorrectValueSpecified); }
// Raises the ValueChanged event. private void OnValueChanged(Int32 oldValue, Int32 newValue) { // Copy the event handlers - this is for thread safty to // avoid that somebody changes the handler to null after // we checked that it is not null but before we called // the handler. ValueChangedHandler valueChangedHandler = this.ValueChanged; // Check if we must notify anybody. if (valueChangedHandler != null) { // Call all methods added to this event. valueChangedHandler(this, oldValue, newValue); } }
public void SetValueChangedHandlerForSubParams(ValueChangedHandler action) { ValueChanged += action; foreach (Parameter p in GetSubParameters().GetAllParameters()) { if (p is IntParam || p is DoubleParam) { p.ValueChanged += action; } else if (p is SingleChoiceWithSubParams) { ((SingleChoiceWithSubParams)p).SetValueChangedHandlerForSubParams(action); } } }
public SecondaryAttribute(string name, Formula formula, BaseAttribute[] attributes, float minValue = float.MinValue, float maxValue = float.MaxValue) : base(name, minValue, maxValue) { _formula = formula; _attributes = attributes; _handlers = new ValueChangedHandler[attributes.Length]; for (int i = 0; i < Attributes.Length; i++) { _handlers[i] = new ValueChangedHandler(ValueOfFormulatAttributeChanged); Attributes[i].OnValueChanged += _handlers[i]; } }
private bool SetupConnection(AppServiceTriggerDetails triggerDetails) { if (triggerDetails == null) { Debug.WriteLine("ForegroundBridgeService started without details, exiting."); return(false); } if (!triggerDetails.Name.Equals("com.microsoft.showcase.appservice")) { Debug.WriteLine("Trigger details name doesn't match com.microsoft.showcase.bridge, exiting."); return(false); } Debug.WriteLine("New service connection."); _connection = triggerDetails.AppServiceConnection; _connection.RequestReceived += OnRequestReceived; ValueChanged += BroadcastReceivedMessage; return(true); }
public void On(string listenOnName, ValueChangedHandler callback) { if (_on.TryGetValue(listenOnName, out var list)) { foreach (var reg in list) { if (reg == callback) { return; } } } else { list = new List <ValueChangedHandler>(); _on.Add(listenOnName, list); } list.Add(callback); }
public VolumeAttribute(string name, Formula formula, BaseAttribute[] attributes, float minValue = float.MinValue, float maxValue = float.MaxValue) : base() { Name = name; _formula = formula; _attributes = attributes; _handlers = new ValueChangedHandler[attributes.Length]; for (int i = 0; i < Attributes.Length; i++) { _handlers[i] = new ValueChangedHandler(ValueOfFormulatAttributeChanged); Attributes[i].OnValueChanged += _handlers[i]; } MinValue = minValue; MaxValue = maxValue; _currentValue = BaseValue; _absoluteMaxValue = maxValue; }
public override object AddValueChangedHandler (object dataItem, EventHandler<EventArgs> handler) { if (dataItem == null) return false; var notify = dataItem as INotifyPropertyChanged; if (notify != null) { var helper = new ValueChangedHandler { Binding = this, DataItem = dataItem, Handler = handler }; notify.PropertyChanged += helper.HandlePropertyChanged; return helper; } else { var type = dataItem.GetType (); var changedEvent = type.GetEvent (Property + "Changed"); if (changedEvent != null) changedEvent.AddEventHandler (dataItem, handler); return dataItem; } }
public static ConfigPropertyInfo FromConfigPropertyAttribute(ConfigPropertyAttribute attribute, string propertyName, object value, Type type, ValueChangedHandler valueChangedDelegate) { // Process list types var attributeList = attribute as ConfigListPropertyAttribute; if (attributeList != null) { var info = new ConfigListPropertyInfo { DisplayName = attribute.DisplayName, PropertyName = propertyName, Description = attribute.Description, DefaultValue = attribute.DefaultValue, Value = value, Type = type, _valueChangedDelegate = valueChangedDelegate }; // Set brush color var color = ColorConverter.ConvertFromString(attributeList.Color); info.Brush = color != null ? new SolidColorBrush((Color)color) : PickBrush(); // Determine default item type if (info.Type.GenericTypeArguments.Length > 0) { info.DefaultListItemType = info.Type.GenericTypeArguments[0]; } return(info); } // Return default object return(new ConfigPropertyInfo { DisplayName = attribute.DisplayName, PropertyName = propertyName, Description = attribute.Description, DefaultValue = attribute.DefaultValue, Value = value, Type = type, _valueChangedDelegate = valueChangedDelegate }); }
private void OnValueChanged(string id, double value) { ValueChangedHandler?.Invoke(id, value); }
/// <summary> /// Wires an event handler to fire when the property of the dataItem is changed /// </summary> /// <param name="dataItem">object to detect changes on</param> /// <param name="handler">handler to fire when the property changes on the specified dataItem</param> /// <returns>binding reference used to track the event hookup, to pass to <see cref="RemoveValueChangedHandler"/> when removing the handler</returns> public override object AddValueChangedHandler (object dataItem, EventHandler<EventArgs> handler) { #if WINRT throw new NotImplementedException(); #else if (dataItem == null) return false; var notify = dataItem as INotifyPropertyChanged; if (notify != null) { var helper = new ValueChangedHandler { Binding = this, DataItem = dataItem, Handler = handler }; notify.PropertyChanged += helper.HandlePropertyChanged; return helper; } else { var type = dataItem.GetType (); var changedEvent = type.GetEvent (Property + "Changed"); if (changedEvent != null) { try { changedEvent.AddEventHandler (dataItem, handler); } catch {} } return dataItem; } #endif }
public static TableAdapter WriteDataTable(DataTable dataTable, TableName tname, Locator locator, string[] columnNames, RowChangedHandler rowChangedHandler, ValueChangedHandler columnHandler) { if (dataTable == null) { return(null); } if (locator == null) { locator = new Locator(tname); } TableAdapter adapter = new TableAdapter(dataTable, tname, locator); if (rowChangedHandler != null) { adapter.DataRowChangedHandler += rowChangedHandler; } if (columnHandler != null) { adapter.ValueChangedHandler = columnHandler; } adapter.AddFields(columnNames); adapter.Save(); return(adapter); }
public virtual bool Save(Selector columnNames, RowChangedHandler rowHandler, ValueChangedHandler columnHandler) { if (dataTable == null || dataTable.Rows.Count == 0) { return(false); } //update this.dataTable // this.AcceptChanges(); objectPermission = ObjectPermission.DenyUpdateObject; RowAdapter d = this.NewSqlRow(columnNames); d.RowChanged += RowChanged; if (rowHandler != null) { d.RowChanged += rowHandler; } if (columnHandler != null) { d.ValueChangedHandler = columnHandler; } else { d.ValueChangedHandler = ValueChanged; } int count = 0; foreach (DataRow dataRow in dataTable.Rows) { BeforeSave(dataRow); if (dataRow.RowState != DataRowState.Deleted) { if (dataRow.RowState != DataRowState.Unchanged) { d.CopyFrom(dataRow); d.Fill(); d.Save(); if (dataRow.RowState == DataRowState.Added) //in case of existing identity columns { d.CopyTo(dataRow); UpdateObject(dataRow); } //slow version //T t = this[dataRow]; //t.Save(d); count++; } } else { dataRow.RejectChanges(); d.CopyFrom(dataRow); d.Fill(); d.Delete(); //slow version //T t = this[dataRow]; //t.Delete(); dataRow.Delete(); } AfterSave(dataRow); } dataTable.AcceptChanges(); objectPermission = ObjectPermission.AllowUpdateObject; return(true); }
public static TableAdapter WriteDataTable(DataTable dataTable, TableName tname, Locator locator, string[] columnNames, RowChangedHandler rowChangedHandler, ValueChangedHandler columnHandler) { if (dataTable == null) return null; if (locator == null) locator = new Locator(tname); TableAdapter adapter = new TableAdapter(dataTable, tname, locator); if(rowChangedHandler != null) adapter.DataRowChangedHandler += rowChangedHandler; if (columnHandler != null) adapter.ValueChangedHandler = columnHandler; adapter.AddFields(columnNames); adapter.Save(); return adapter; }