2006-12-26 Jonathan Pobst <monkey@jpobst.com>

[mono.git] / mcs / class / Managed.Windows.Forms / System.Windows.Forms / Binding.cs

diff --git a/mcs/class/Managed.Windows.Forms/System.Windows.Forms/Binding.cs b/mcs/class/Managed.Windows.Forms/System.Windows.Forms/Binding.cs
index d81250e981eadb16e9a955900af339085580e3c7..7fe7b29b1e89c9b9f6f71ebda8ceb1939cce8e15 100644 (file)
--- a/mcs/class/Managed.Windows.Forms/System.Windows.Forms/Binding.cs
+++ b/mcs/class/Managed.Windows.Forms/System.Windows.Forms/Binding.cs
@@ -35,12 +35,16 @@ namespace System.Windows.Forms {
                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 Type data_type;
 
                #region Public Constructors
                public Binding (string propertyName, object dataSource, string dataMember)
@@ -78,10 +82,13 @@ namespace System.Windows.Forms {
                        }
                }
 
-               [MonoTODO]
                public bool IsBinding {
                        get {
-                               return false;
+                               if (control == null || !control.Created)
+                                       return false;
+                               if (manager == null || manager.IsSuspended)
+                                       return false;
+                               return true;
                        }
                }
 
@@ -105,9 +112,6 @@ namespace System.Windows.Forms {
                        if (Parse!=null)
                                Parse (this, cevent);
                }
-
-
-
                #endregion      // Protected Instance Methods
 
                
@@ -116,36 +120,66 @@ namespace System.Windows.Forms {
                        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 = control.BindingContext [data_source, data_member];
+
                        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 ()
                {
-                       PropertyDescriptor pd = TypeDescriptor.GetProperties (manager.Current).Find (data_member, true);
-                       data = pd.GetValue (manager.Current);
+                       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) {
+                                       data = Convert.DBNull;
+                                       return;
+                               }
+                       }
+
+                       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 ()
@@ -153,6 +187,86 @@ namespace System.Windows.Forms {
                        PushData ();
                }
 
+               private void SetControlValue (object data)
+               {
+                       control_property.SetValue (control, data);
+               }
+
+               private void SetPropertyValue (object data)
+               {
+                       PropertyDescriptor pd = TypeDescriptor.GetProperties (manager.Current).Find (binding_member_info.BindingField, true);
+                       if (pd.IsReadOnly)
+                               return;
+                       data = ParseData (data, pd.PropertyType);
+                       pd.SetValue (manager.Current, data);
+               }
+
+               private void CurrentChangedHandler (object sender, EventArgs e)
+               {
+                       PushData ();
+               }
+
+               private void ControlValidatingHandler (object sender, CancelEventArgs e)
+               {
+                       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
                public event ConvertEventHandler Format;
                public event ConvertEventHandler Parse;