private string property_name;
private object data_source;
private string data_member;
+
private BindingMemberInfo binding_member_info;
private Control control;
private BindingManagerBase manager;
- private PropertyDescriptor prop_desc;
+ private PropertyDescriptor control_property;
private PropertyDescriptor is_null_desc;
- private object data;
- private EventDescriptor changed_event;
- private EventHandler property_value_changed_handler;
- private object event_current; // The manager.Current as far as the changed_event knows
+ private object data;
+ private Type data_type;
#region Public Constructors
public Binding (string propertyName, object dataSource, string dataMember)
}
}
- [MonoTODO]
public bool IsBinding {
get {
- return false;
+ if (control == null || !control.Created)
+ return false;
+ if (manager == null || manager.IsSuspended)
+ return false;
+ return true;
}
}
if (control == this.control)
return;
- prop_desc = TypeDescriptor.GetProperties (control).Find (property_name, false);
+ control_property = TypeDescriptor.GetProperties (control).Find (property_name, true);
- if (prop_desc == null)
+ if (control_property == null)
throw new ArgumentException (String.Concat ("Cannot bind to property '", property_name, "' on target control."));
- if (prop_desc.IsReadOnly)
+ 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.Validating += new CancelEventHandler (ControlValidatingHandler);
this.control = control;
internal void Check (BindingContext binding_context)
{
- if (control == null)
+ if (control == null || control.BindingContext == null)
return;
- manager = control.BindingContext [data_source, property_name];
- manager.AddBinding (this);
+ manager = control.BindingContext [data_source, data_member];
- WirePropertyValueChangedEvent ();
+ manager.AddBinding (this);
+ manager.PositionChanged += new EventHandler (PositionChangedHandler);
+ manager.CurrentChanged += new EventHandler (CurrentChangedHandler);
is_null_desc = TypeDescriptor.GetProperties (manager.Current).Find (property_name + "IsNull", false);
- PullData ();
PushData ();
}
- internal void PushData ()
+ internal void PullData ()
{
- prop_desc.SetValue (control, data);
+ if (IsBinding == false || manager.Current == null)
+ return;
+
+ data = control_property.GetValue (control);
+ SetPropertyValue (data);
}
- internal void PullData ()
+ internal void PushData ()
{
+ if (manager == null || manager.IsSuspended || manager.Current == null)
+ return;
+
if (is_null_desc != null) {
bool is_null = (bool) is_null_desc.GetValue (manager.Current);
if (is_null) {
}
}
- PropertyDescriptor pd = TypeDescriptor.GetProperties (manager.Current).Find (data_member, true);
- data = pd.GetValue (manager.Current);
+ PropertyDescriptor pd = TypeDescriptor.GetProperties (manager.Current).Find (binding_member_info.BindingField, true);
+ if (pd == null) {
+ data = ParseData (manager.Current, manager.Current.GetType ());
+ } else {
+ data = ParseData (pd.GetValue (manager.Current), pd.PropertyType);
+ }
+
+ data = FormatData (data);
+ SetControlValue (data);
}
internal void UpdateIsBinding ()
PushData ();
}
- private void CurrentChangedHandler ()
+ private void SetControlValue (object data)
{
- if (changed_event != null) {
- changed_event.RemoveEventHandler (event_current, property_value_changed_handler);
- WirePropertyValueChangedEvent ();
- }
+ control_property.SetValue (control, data);
}
- private void WirePropertyValueChangedEvent ()
+ private void SetPropertyValue (object data)
{
- EventDescriptor changed_event = TypeDescriptor.GetEvents (manager.Current).Find (property_name + "Changed", false);
- if (changed_event == null)
+ PropertyDescriptor pd = TypeDescriptor.GetProperties (manager.Current).Find (binding_member_info.BindingField, true);
+ if (pd.IsReadOnly)
return;
- property_value_changed_handler = new EventHandler (PropertyValueChanged);
- changed_event.AddEventHandler (manager.Current, property_value_changed_handler);
-
- event_current = manager.Current;
+ data = ParseData (data, pd.PropertyType);
+ pd.SetValue (manager.Current, data);
}
- private void PropertyValueChanged (object sender, EventArgs e)
+ private void CurrentChangedHandler (object sender, EventArgs e)
{
- PullData ();
PushData ();
}
private void ControlValidatingHandler (object sender, CancelEventArgs e)
{
- PullData ();
+ object old_data = data;
+
+ // If the data doesn't seem to be valid (it can't be converted,
+ // is the wrong type, etc, we reset to the old data value.
+ try {
+ PullData ();
+ } catch {
+ data = old_data;
+ SetControlValue (data);
+ }
+ }
+
+ private void PositionChangedHandler (object sender, EventArgs e)
+ {
+ PushData ();
+ }
+
+ private object ParseData (object data, Type data_type)
+ {
+ ConvertEventArgs e = new ConvertEventArgs (data, data_type);
+
+ OnParse (e);
+ if (data_type.IsInstanceOfType (e.Value))
+ return e.Value;
+ if (e.Value == Convert.DBNull)
+ return e.Value;
+
+ return ConvertData (e.Value, data_type);
+ }
+
+ private object FormatData (object data)
+ {
+ if (data_type == typeof (object))
+ return data;
+
+ ConvertEventArgs e = new ConvertEventArgs (data, data_type);
+
+ OnFormat (e);
+ if (data_type.IsInstanceOfType (e.Value))
+ return e.Value;
+
+ return ConvertData (data, data_type);
+ }
+
+ private object ConvertData (object data, Type data_type)
+ {
+ TypeConverter converter = TypeDescriptor.GetConverter (data.GetType ());
+ if (converter != null && converter.CanConvertTo (data_type))
+ return converter.ConvertTo (data, data_type);
+
+ if (data is IConvertible) {
+ object res = Convert.ChangeType (data, data_type);
+ if (data_type.IsInstanceOfType (res))
+ return res;
+ }
+
+ return null;
}
#region Events
projects / mono.git / blobdiff