internal void SetBindableComponent(IBindableComponent value) { if (this.control != value) { IBindableComponent oldTarget = control; BindTarget(false); this.control = value; BindTarget(true); try { CheckBinding(); } catch { BindTarget(false); control = oldTarget; BindTarget(true); throw; } // We are essentially doing to the listManager what we were doing to the // BindToObject: bind only when the control is created and it has a BindingContext BindingContext.UpdateBinding((control != null && IsComponentCreated(control) ? control.BindingContext: null), this); Form form = value as Form; if (form != null) { form.Load += new EventHandler(FormLoaded); } } }
private static void Bind(IBindableComponent bindable, Item item) { bindable.DataBindings.Add("Text", item, "Text"); bindable.DataBindings.Add("ToolTipText", item, "ToolTipText"); bindable.DataBindings.Add("Enabled", item, "Enabled"); bindable.DataBindings.Add("Visible", item, "Visible"); }
public ControlBindingsCollection(IBindableComponent control) { bindable_component = control; //control = control as Widget; default_datasource_update_mode = DataSourceUpdateMode.OnValidation; }
void AddDataBinding(IBindableComponent component, string propertyName, object dataSource, string dataMember) { Binding dataBinding = new Binding(propertyName, dataSource, dataMember, false, DataSourceUpdateMode.OnPropertyChanged); component.DataBindings.Add(dataBinding); _dataBindings.Add(dataBinding); }
internal void SetBindableComponent(IBindableComponent value) { if (this.control != value) { IBindableComponent control = this.control; this.BindTarget(false); this.control = value; this.BindTarget(true); try { this.CheckBinding(); } catch { this.BindTarget(false); this.control = control; this.BindTarget(true); throw; } BindingContext.UpdateBinding(((this.control != null) && IsComponentCreated(this.control)) ? this.control.BindingContext : null, this); Form form = value as Form; if (form != null) { form.Load += new EventHandler(this.FormLoaded); } } }
public static void Bind <T, U>(this IBindableComponent component, Binding binding, Func <T, U> transform) { binding.Parse += (s, e) => e.Value = transform((T)e.Value); binding.Format += (s, e) => e.Value = transform((T)e.Value); component.DataBindings.Add(binding); }
internal void SetBindableComponent(IBindableComponent value) { if (BindableComponent != value) { IBindableComponent oldTarget = BindableComponent; BindTarget(false); BindableComponent = value; BindTarget(true); try { CheckBinding(); } catch { BindTarget(false); BindableComponent = oldTarget; BindTarget(true); throw; } // We are essentially doing to the listManager what we were doing to the // BindToObject: bind only when the control is created and it has a BindingContext BindingContext.UpdateBinding((BindableComponent is not null && IsComponentCreated(BindableComponent) ? BindableComponent.BindingContext : null), this); if (value is Form form) { form.Load += new EventHandler(FormLoaded); } } }
internal ControlBindingsCollection (Control control) { this.control = control; #if NET_2_0 bindable_component = control as IBindableComponent; default_datasource_update_mode = DataSourceUpdateMode.OnValidation; #endif }
private void Bind(IBindableComponent control, string property) { if (control != null) { control.DataBindings.Add("Text", vault, property, true, DataSourceUpdateMode.OnPropertyChanged, 0, "000"); } }
public Binding BindObject(IBindableComponent bindableObj, IColumn column, NullValue nullValue) { if (dbManager.GetDataColumn(column).DefaultValue is System.DBNull && nullValue == NullValue.SetNull) { dbManager.GetDataColumn(column).DefaultValue = column.DefaultValue; } return(bindableObj.DataBindings.Add("Value", dbManager.MasterBinding, column.Name)); }
internal ControlBindingsCollection(Control control) { this.control = control; #if NET_2_0 bindable_component = control as IBindableComponent; default_datasource_update_mode = DataSourceUpdateMode.OnValidation; #endif }
public static Binding AddDataBinding <TD, TDp>( IBindableComponent control, TD data, Expression <Func <TD, TDp> > dataProperty) { if (control == null) { throw new ArgumentNullException(nameof(control)); } if (dataProperty == null) { throw new ArgumentNullException(nameof(dataProperty)); } var dataMemberBody = (MemberExpression)dataProperty.Body; var dataMemberName = dataMemberBody.Member.Name; string name = null; // Add TextBox. var textBox = control as TextBox; if (textBox != null) { name = nameof(textBox.Text); } // Add ComboBox. var comboBox = control as ComboBox; if (comboBox != null) { name = string.IsNullOrEmpty(comboBox.ValueMember) ? nameof(comboBox.SelectedItem) : nameof(comboBox.SelectedValue); } // Add CheckBox. var checkBox = control as CheckBox; if (checkBox != null) { name = nameof(checkBox.Checked); } // Add NumericUpDown. var upDown = control as NumericUpDown; if (upDown != null) { name = nameof(upDown.Value); } // If type is missing then throw error. if (string.IsNullOrEmpty(name)) { throw new Exception(string.Format("Add control Type '{0}' to ControlsHelper.AddDataBinding(control, data, dataProperty) method!", control.GetType())); } // Add data binding. return(control.DataBindings.Add(name, data, dataMemberName, false, DataSourceUpdateMode.OnPropertyChanged, null, null, null)); }
internal static bool IsComponentCreated(IBindableComponent component) { System.Windows.Forms.Control control = component as System.Windows.Forms.Control; if (control != null) { return(control.Created); } return(true); }
/// <summary> /// Attaches a binding to a component, using the given format transformation. /// </summary> /// /// <typeparam name="TSource">The type of the source property.</typeparam> /// <typeparam name="TDestination">The type of the destination.</typeparam> /// /// <param name="component">The component to which the binding applies (such as a control in the form).</param> /// <param name="propertyName">The name of the control property to bind.</param> /// <param name="dataSource">An object that represents the data source.</param> /// <param name="dataMember">The property or list to bind to.</param> /// <param name="format">The format transformation which transforms the model's property to a control's value.</param> /// public static Binding Bind <TSource, TDestination>(this IBindableComponent component, string propertyName, object dataSource, string dataMember, Func <TSource, TDestination> format) { if (component == null) { throw new ArgumentNullException("component"); } return(Bind(component, new Binding(propertyName, dataSource, dataMember), format)); }
public void Ctor_IBindableComponent(IBindableComponent control, Control expectedControl) { var collection = new ControlBindingsCollection(control); Assert.Same(control, collection.BindableComponent); Assert.Same(expectedControl, collection.Control); Assert.Equal(DataSourceUpdateMode.OnValidation, collection.DefaultDataSourceUpdateMode); Assert.Empty(collection); }
/// <summary> /// Attaches a binding to a component, using the given format transformation. /// </summary> /// /// <param name="component">The component to which the binding applies (such as a control in the form).</param> /// <param name="binding">The binding object which defines the property being bound (such as a ViewModel property).</param> /// public static Binding Bind(this IBindableComponent component, Binding binding) { if (component == null) { throw new ArgumentNullException("component"); } component.DataBindings.Add(binding); return(binding); }
private static void SetBinding(IBindableComponent control, string propertyName, object dataSource, string dataMember) { Contract.Requires(control != null); Contract.Requires(propertyName != null); Contract.Requires(dataSource != null); Contract.Requires(dataMember != null); control.DataBindings.Add(propertyName, dataSource, dataMember, true, DataSourceUpdateMode.OnPropertyChanged); }
public static void Bind <T>(this IBindableComponent component, T value, Expression <Func <object> > controlProperty, Expression <Func <T, object> > modelProperty) where T : INotifyPropertyChanged { component.DataBindings.Add(new Binding( StringExtensions.PropertyName(controlProperty), value, StringExtensions.PropertyName(modelProperty), true, DataSourceUpdateMode.OnPropertyChanged)); }
/// <summary> /// Method for retrieving the bound meta data column of a given editor. /// </summary> private MetaDataColumn getEditorColumn(IBindableComponent editor) { if (editor.DataBindings.Count == 0) { return(null); } var colName = editor.DataBindings[0].BindingMemberInfo.BindingField; return(!_data.Columns.ContainsName(colName) ? null : _data.Columns.ItemByName(colName)); }
protected void Bind(IBindableComponent component, string propertyName, string dataMember, IValueConverter converter = null, DataSourceUpdateMode dataSourceUpdateMode = DataSourceUpdateMode.OnPropertyChanged) { var binding = new CustomBinding(propertyName, this, dataMember, converter) { DataSourceUpdateMode = dataSourceUpdateMode, ControlUpdateMode = ControlUpdateMode.OnPropertyChanged }; component.DataBindings.Add(binding); _bindings[dataMember] = binding; }
/// <summary> /// Initializes a new instance of the <see cref="BindingProviderBase<T>"/> class. /// </summary> /// <param name="bindableComponent">The owner.</param> protected BindingProviderBase(IBindableComponent bindableComponent) { this.owner = bindableComponent; if (this.owner != null) { this.bindingContext = owner.BindingContext; } this.logicalItems = new List <T>(); this.UpdateLogicalPropertiesCache(); }
public void SetMemoBobinaControl(ACBrECF ecf, IBindableComponent control) { ECFInfo info; if (!this.infos.TryGetValue(ecf.Handle, out info)) { info = new ECFInfo(); info.ECF = ecf; infos.Add(ecf.Handle, info); } info.Control = control; }
// Is the binadable component in a 'created' (ready-to-use) state? For controls, // this depends on whether the window handle has been created yet. For everything // else, we'll assume they are always in a created state. internal static bool IsComponentCreated(IBindableComponent component) { Control ctrl = (component as Control); if (ctrl != null) { return(ctrl.Created); } else { return(true); } }
public static bool IsBound(this GridItem item, out IBindableComponent component) { if (item == null) { throw new ArgumentNullException(nameof(item)); } if (GetBindableObject(item) is IBindableComponent bindableComponent && (item.PropertyDescriptor?.Attributes.OfType <BindableAttribute>().FirstOrDefault() ?? BindableAttribute.Default).Bindable) { component = bindableComponent; return(bindableComponent.DataBindings.Cast <Binding>().Any(b => b.PropertyName == GetBindablePropertyDescriptor(item.PropertyDescriptor).Name)); } component = null; return(false); }
// private void rbSplit_CheckedChanged(object sender, EventArgs e) { // if (rbSplit.Checked) SplitBehavior = SplitBehavior.Split; // } // // private void rbSkip_CheckedChanged(object sender, EventArgs e) { // if (rbSkip.Checked) SplitBehavior = SplitBehavior.Skip; // } private void AddRadioCheckedBinding <T>(IBindableComponent component, object dataSource, string dataMember, T trueValue) { var binding = new Binding(nameof(RadioButton.Checked), dataSource, dataMember, true, DataSourceUpdateMode.OnPropertyChanged); binding.Parse += (s, a) => { if ((bool)a.Value) { a.Value = trueValue; } }; binding.Format += (s, a) => a.Value = ((T)a.Value).Equals(trueValue); component.DataBindings.Add(binding); }
/// <summary> /// Attaches a binding to a component, using the given format transformation. /// </summary> /// /// <param name="component">The component to which the binding applies (such as a control in the form).</param> /// <param name="propertyName">The name of the control property to bind.</param> /// <param name="dataSource">An object that represents the data source.</param> /// <param name="dataMember">The property or list to bind to.</param> /// public static Binding Bind(this IBindableComponent component, string propertyName, object dataSource, string dataMember) { if (component == null) { throw new ArgumentNullException("component"); } Binding binding = new Binding(propertyName, dataSource, dataMember); binding.DataSourceUpdateMode = DataSourceUpdateMode.OnPropertyChanged; binding.ControlUpdateMode = ControlUpdateMode.OnPropertyChanged; return(Bind(component, binding)); }
/// <summary> /// Attaches a binding to a component, using the given format transformation. /// </summary> /// /// <typeparam name="TSource">The type of the source property.</typeparam> /// <typeparam name="TDestination">The type of the destination.</typeparam> /// /// <param name="component">The component to which the binding applies (such as a control in the form).</param> /// <param name="binding">The binding object which defines the property being bound (such as a ViewModel property).</param> /// <param name="format">The format transformation which transforms the model's property to a control's value.</param> /// public static Binding Bind <TSource, TDestination>(this IBindableComponent component, Binding binding, Func <TSource, TDestination> format) { if (component == null) { throw new ArgumentNullException("component"); } if (binding == null) { throw new ArgumentNullException("binding"); } binding.Format += (sender, e) => e.Value = format((TSource)e.Value); binding.FormattingEnabled = true; component.DataBindings.Add(binding); return(binding); }
internal void SetControl(IBindableComponent control) { if (control == this.control) { return; } this.source = (control is IBindableDecorator) ? ((IBindableDecorator)control).Component : control; control_property = TypeDescriptor.GetProperties(source).Find(property_name, true); if (control_property == null) { throw new ArgumentException(String.Concat("Cannot bind to property '", property_name, "' on target control.")); } if (control_property.IsReadOnly) { throw new ArgumentException(String.Concat("Cannot bind to property '", property_name, "' because it is read only.")); } data_type = control_property.PropertyType; // Getting the PropertyType is kinda slow and it should never change, so it is cached /*Widget ctrl = control as Widget; * if (ctrl != null) { * ctrl.Validating += new CancelEventHandler (ControlValidatingHandler); * if (!ctrl.IsHandleCreated) * ctrl.HandleCreated += new EventHandler (ControlCreatedHandler); * }*/ control.Validating += new CancelEventHandler(ControlValidatingHandler); // if (!control.IsHandleCreated) // control.HandleCreated += new EventHandler (ControlCreatedHandler); EventDescriptor prop_changed_event = GetPropertyChangedEvent(source, property_name); if (prop_changed_event != null) { prop_changed_event.AddEventHandler(control, new EventHandler(ControlPropertyChangedHandler)); } this.control = control; UpdateIsBinding(); }
internal void SetControl(Control control) #endif { if (control == this.control) { return; } control_property = TypeDescriptor.GetProperties(control).Find(property_name, true); if (control_property == null) { throw new ArgumentException(String.Concat("Cannot bind to property '", property_name, "' on target control.")); } if (control_property.IsReadOnly) { throw new ArgumentException(String.Concat("Cannot bind to property '", property_name, "' because it is read only.")); } data_type = control_property.PropertyType; // Getting the PropertyType is kinda slow and it should never change, so it is cached Control ctrl = control as Control; if (ctrl != null) { ctrl.Validating += new CancelEventHandler(ControlValidatingHandler); if (!ctrl.IsHandleCreated) { ctrl.HandleCreated += new EventHandler(ControlCreatedHandler); } } #if NET_2_0 EventDescriptor prop_changed_event = GetPropertyChangedEvent(control, property_name); if (prop_changed_event != null) { prop_changed_event.AddEventHandler(control, new EventHandler(ControlPropertyChangedHandler)); } #endif this.control = control; UpdateIsBinding(); }
private void PushChanges() { if (this.Dirty) { IComponentChangeService service = this.host.GetService(typeof(IComponentChangeService)) as IComponentChangeService; PropertyDescriptor member = null; IBindableComponent bindableComponent = this.bindings.BindableComponent; if ((service != null) && (bindableComponent != null)) { member = TypeDescriptor.GetProperties(bindableComponent)["DataBindings"]; if (member != null) { service.OnComponentChanging(bindableComponent, member); } } this.bindings.Clear(); TreeNode node = this.propertiesTreeView.Nodes[0]; for (int i = 0; i < node.Nodes.Count; i++) { BindingTreeNode node2 = node.Nodes[i] as BindingTreeNode; if (node2.Binding != null) { this.bindings.Add(node2.Binding); } } TreeNode node3 = this.propertiesTreeView.Nodes[1]; for (int j = 0; j < node3.Nodes.Count; j++) { BindingTreeNode node4 = node3.Nodes[j] as BindingTreeNode; if (node4.Binding != null) { this.bindings.Add(node4.Binding); } } if (((service != null) && (bindableComponent != null)) && (member != null)) { service.OnComponentChanged(bindableComponent, member, null, null); } } }
private void Bind(IBindableComponent bindable, Item item) { _bindingManager.Bindings.Add(new Binding(bindable, "Text", item, "Text") { Mode = BindingMode.OneWayToTarget }); _bindingManager.Bindings.Add(new Binding(bindable, "ToolTipText", item, "ToolTipText") { Mode = BindingMode.OneWayToTarget }); _bindingManager.Bindings.Add(new Binding(bindable, "Enabled", item, "Enabled") { Mode = BindingMode.OneWayToTarget }); _bindingManager.Bindings.Add(new Binding(bindable, "Visible", item, "Visible") { Mode = BindingMode.OneWayToTarget }); }
public ControlBindingsCollection(IBindableComponent control) { this.control = control; }
internal void SetControl (IBindableComponent control) { if (control == this.control) return; control_property = TypeDescriptor.GetProperties (control).Find (property_name, true); if (control_property == null) throw new ArgumentException (String.Concat ("Cannot bind to property '", property_name, "' on target control.")); if (control_property.IsReadOnly) throw new ArgumentException (String.Concat ("Cannot bind to property '", property_name, "' because it is read only.")); data_type = control_property.PropertyType; // Getting the PropertyType is kinda slow and it should never change, so it is cached Control ctrl = control as Control; if (ctrl != null) { ctrl.Validating += new CancelEventHandler (ControlValidatingHandler); if (!ctrl.IsHandleCreated) ctrl.HandleCreated += new EventHandler (ControlCreatedHandler); } EventDescriptor prop_changed_event = GetPropertyChangedEvent (control, property_name); if (prop_changed_event != null) prop_changed_event.AddEventHandler (control, new EventHandler (ControlPropertyChangedHandler)); this.control = control; UpdateIsBinding (); }
internal ControlBindingsCollection(Widget control) { bindable_component = control as IBindableComponent; default_datasource_update_mode = DataSourceUpdateMode.OnValidation; }
/// <include file='doc\ControlBindingsCollection.uex' path='docs/doc[@for="ControlBindingsCollection.ControlBindingsCollection"]/*' /> public ControlBindingsCollection(IBindableComponent control) : base() { Debug.Assert(control != null, "How could a controlbindingscollection not have a control associated with it!"); this.control = control; }
/// <summary> /// Processes the control. /// </summary> /// <param name="control">The control.</param> private void ProcessControl(IBindableComponent control) { if (control == null) throw new ArgumentNullException("control"); bool hasWarning = false; bool hasInfo = false; foreach (Binding binding in control.DataBindings) { // get the Binding if appropriate if (binding.DataSource == DataSource) { string propertyName = binding.BindingMemberInfo.BindingField; bool bError = _errorList.ContainsKey(propertyName); bool bWarn = _warningList.ContainsKey(propertyName); bool bInfo = _infoList.ContainsKey(propertyName); // set flags to indicat if Warning or Info is highest severity; else false if (_showMostSevereOnly) { bInfo = bInfo && !bWarn && !bError; bWarn = bWarn && !bError; } int offsetInformation = _offsetInformation; int offsetWarning = _offsetWarning; // Set / fix offsets // by default the setting are correct for Error (0), Warning and Info if (!bError) { if (bWarn) { // warning and possibly info, no error offsetInformation = _offsetInformation - _offsetWarning; offsetWarning = 0; } else { // Info only offsetInformation = 0; } } else if (!bWarn) { offsetInformation = _offsetInformation - _offsetWarning; } // should warning be visible if (_visibleWarning && bWarn) { errorProviderWarn.SetError(binding.Control, _warningList[propertyName]); errorProviderWarn.SetIconPadding(binding.Control, base.GetIconPadding(binding.Control) + offsetWarning); errorProviderWarn.SetIconAlignment(binding.Control, base.GetIconAlignment(binding.Control)); hasWarning = true; } // should info be shown if (_visibleInformation && bInfo) { errorProviderInfo.SetError(binding.Control, _infoList[propertyName]); errorProviderInfo.SetIconPadding(binding.Control, base.GetIconPadding(binding.Control) + offsetInformation); errorProviderInfo.SetIconAlignment(binding.Control, base.GetIconAlignment(binding.Control)); hasInfo = true; } } } if (!hasWarning) errorProviderWarn.SetError((Control)control, string.Empty); if (!hasInfo) errorProviderInfo.SetError((Control)control, string.Empty); }
// Is the binadable component in a 'created' (ready-to-use) state? For controls, // this depends on whether the window handle has been created yet. For everything // else, we'll assume they are always in a created state. internal static bool IsComponentCreated(IBindableComponent component) { Control ctrl = (component as Control); if (ctrl != null) { return ctrl.Created; } else { return true; } }
// Constructors public ControlBindingsCollection(IBindableComponent control) {}
internal static bool IsComponentCreated(IBindableComponent component) { System.Windows.Forms.Control control = component as System.Windows.Forms.Control; if (control != null) { return control.Created; } return true; }