private static bool ValidDataMember(object dataSource, string dataMember)
 {
     if (!string.IsNullOrEmpty(dataMember))
     {
         BindingManagerBase base2;
         if (bc == null)
         {
             bc = new BindingContext();
         }
         BindingMemberInfo info = new BindingMemberInfo(dataMember);
         PropertyDescriptorCollection itemProperties = null;
         try
         {
             base2 = bc[dataSource, info.BindingPath];
         }
         catch (ArgumentException)
         {
             return false;
         }
         if (base2 == null)
         {
             return false;
         }
         itemProperties = base2.GetItemProperties();
         if (itemProperties == null)
         {
             return false;
         }
         if (itemProperties[info.BindingField] == null)
         {
             return false;
         }
     }
     return true;
 }
Пример #2
0
        private bool BindingMemberInfoInDataManager(BindingMemberInfo bindingMemberInfo)
        {
            if (dataManager == null)
            {
                return(false);
            }
            PropertyDescriptorCollection props = dataManager.GetItemProperties();
            int propsCount = props.Count;

            for (int i = 0; i < propsCount; i++)
            {
                if (typeof(IList).IsAssignableFrom(props[i].PropertyType))
                {
                    continue;
                }
                if (props[i].Name.Equals(bindingMemberInfo.BindingField))
                {
                    return(true);
                }
            }

            for (int i = 0; i < propsCount; i++)
            {
                if (typeof(IList).IsAssignableFrom(props[i].PropertyType))
                {
                    continue;
                }
                if (String.Compare(props[i].Name, bindingMemberInfo.BindingField, true, CultureInfo.CurrentCulture) == 0)
                {
                    return(true);
                }
            }

            return(false);
        }
Пример #3
0
 public Binding(string propertyName, object dataSource, string dataMember)
 {
     property_name       = propertyName;
     data_source         = dataSource;
     data_member         = dataMember;
     binding_member_info = new BindingMemberInfo(dataMember);
 }
Пример #4
0
        private bool BindingMemberInfoInDataManager(BindingMemberInfo bindingMemberInfo)
        {
            if (dataManager == null)
            {
                return(false);
            }
            PropertyDescriptorCollection props = dataManager.GetItemProperties();
            int  propsCount = props.Count;
            bool fieldFound = false;

            for (int i = 0; i < propsCount; i++)
            {
                if (typeof(IList).IsAssignableFrom(props[i].PropertyType))
                {
                    continue;
                }
                if (props[i].Name.Equals(bindingMemberInfo.BindingField))
                {
                    fieldFound = true;
                    break;
                }
            }

            return(fieldFound);
        }
Пример #5
0
	// Constructor.
	public Binding(String propertyName, Object dataSource, String dataMember)
			{
				this.propertyName = propertyName;
				this.dataSource = dataSource;
				this.bindingMemberInfo = new BindingMemberInfo(dataMember);

			}
Пример #6
0
 internal BindToObject(Binding owner, Object dataSource, string dataMember)
 {
     this.owner      = owner;
     this.dataSource = dataSource;
     this.dataMember = new BindingMemberInfo(dataMember);
     CheckBinding();
 }
Пример #7
0
 /// <summary>
 /// Initializes a new instance of the BindingDef class.
 /// </summary>
 /// <param name="propertyName"></param>
 /// <param name="dataMember"></param>
 public BindingDef(string propertyName, string dataMember)
 {
     _PropertyName = propertyName;
     _PropertyPath = propertyName.Split('.');
     _DataMember = dataMember;
     _BindingMemberInfo = new BindingMemberInfo(dataMember);
 }
Пример #8
0
		public void CtorEmpty ()
		{
			BindingMemberInfo bmi = new BindingMemberInfo ("...");

			Assert.AreEqual (bmi.BindingMember, "...", "CTEMPTY1");
			Assert.AreEqual (bmi.BindingPath, "..", "CTEMPTY2");
			Assert.AreEqual (bmi.BindingField, String.Empty, "CTEMPTY3");
		}
Пример #9
0
		public void CtorAll ()
		{
			BindingMemberInfo bmi = new BindingMemberInfo ("Member.Path.Field");

			Assert.AreEqual (bmi.BindingMember, "Member.Path.Field", "CTALL1");
			Assert.AreEqual (bmi.BindingPath, "Member.Path", "CTALL2");
			Assert.AreEqual (bmi.BindingField, "Field", "CTALL3");
		}
Пример #10
0
		public void CtorMemberAndPathOnly ()
		{
			BindingMemberInfo bmi = new BindingMemberInfo ("Member.Path");

			Assert.AreEqual (bmi.BindingMember, "Member.Path", "CTMAF1");
			Assert.AreEqual (bmi.BindingPath, "Member", "CTMAF2");
			Assert.AreEqual (bmi.BindingField, "Path", "CTMAF3");
		}
Пример #11
0
		public void CtorMemberOnly ()
		{
			BindingMemberInfo bmi = new BindingMemberInfo ("Member");

			Assert.AreEqual (bmi.BindingMember, "Member", "CTORMEMBER1");
			Assert.AreEqual (bmi.BindingField, "Member", "CTORMEMBER2");
			Assert.AreEqual (bmi.BindingPath, String.Empty, "CTORMEMBER3");
		}
Пример #12
0
		public void CtorNullTest ()
		{
			BindingMemberInfo bmi = new BindingMemberInfo (null);

			Assert.AreEqual (bmi.BindingMember, String.Empty, "CTORNULL1");
			Assert.AreEqual (bmi.BindingField, String.Empty, "CTORNULL2");
			Assert.AreEqual (bmi.BindingPath, String.Empty, "CTORNULL3");
		}
Пример #13
0
 /// <include file='doc\DataMemberInfo.uex' path='docs/doc[@for="BindingMemberInfo.Equals"]/*' />
 /// <devdoc>
 ///    <para>[To be supplied.]</para>
 /// </devdoc>
 public override bool Equals(object otherObject)
 {
     if (otherObject is BindingMemberInfo)
     {
         BindingMemberInfo otherMember = (BindingMemberInfo)otherObject;
         return(String.Compare(this.BindingMember, otherMember.BindingMember, true, CultureInfo.InvariantCulture) == 0);
     }
     return(false);
 }
Пример #14
0
 /// <include file='doc\DataMemberInfo.uex' path='docs/doc[@for="BindingMemberInfo.Equals"]/*' />
 /// <devdoc>
 ///    <para>[To be supplied.]</para>
 /// </devdoc>
 public override bool Equals(object otherObject)
 {
     if (otherObject is BindingMemberInfo)
     {
         BindingMemberInfo otherMember = (BindingMemberInfo)otherObject;
         return(String.Equals(this.BindingMember, otherMember.BindingMember, StringComparison.OrdinalIgnoreCase));
     }
     return(false);
 }
        protected ListControl()
        {
            value_member   = new BindingMemberInfo(string.Empty);
            display_member = string.Empty;
            SetStyle(ControlStyles.StandardClick | ControlStyles.UserPaint
#if NET_2_0
                     | ControlStyles.UseTextForAccessibility
#endif
                     , false);
        }
Пример #16
0
		protected ListControl ()
		{
			value_member = new BindingMemberInfo (string.Empty);
			display_member = string.Empty;
			SetStyle (ControlStyles.StandardClick | ControlStyles.UserPaint
#if NET_2_0
				| ControlStyles.UseTextForAccessibility
#endif
				, false);
		}
Пример #17
0
 public Binding(string propertyName, object dataSource, string dataMember, bool formattingEnabled, DataSourceUpdateMode dataSourceUpdateMode, object nullValue, string formatString, IFormatProvider formatInfo)
 {
     property_name          = propertyName;
     data_source            = dataSource;
     data_member            = dataMember;
     binding_member_info    = new BindingMemberInfo(dataMember);
     datasource_update_mode = dataSourceUpdateMode;
     null_value             = nullValue;
     format_string          = formatString;
     format_info            = formatInfo;
 }
Пример #18
0
        public Binding(string propertyName, object dataSource, string dataMember, bool formattingEnabled, DataSourceUpdateMode dataSourceUpdateMode, object nullValue, string formatString, IFormatProvider formatInfo)
        {
            DataSource        = dataSource;
            BindingMemberInfo = new BindingMemberInfo(dataMember);
            _bindToObject     = new BindToObject(this);

            PropertyName         = propertyName;
            _formattingEnabled   = formattingEnabled;
            _formatString        = formatString;
            _nullValue           = nullValue;
            _formatInfo          = formatInfo;
            DataSourceUpdateMode = dataSourceUpdateMode;

            CheckBinding();
        }
Пример #19
0
        public object GetCurrentlyBoundId()
        {
            System.Windows.Forms.Binding binding = GetSelectedValueBinding();
            if (binding == null)
            {
                return(null);
            }
            if (((System.Windows.Forms.BindingSource)binding.DataSource).Count == 0)
            {
                return(null);
            }
            object obj = ((System.Windows.Forms.BindingSource)binding.DataSource)[0];

            System.Type type = obj.GetType();
            System.Windows.Forms.BindingMemberInfo bindingMemberInfo = binding.BindingMemberInfo;
            string s = bindingMemberInfo.BindingMember;

            System.Reflection.PropertyInfo propertyInfo = type.GetProperty(s);
            return(propertyInfo.GetValue(obj, null));
        }
Пример #20
0
 private void UpdateNullBinding()
 {
     if (Nullable && (_ItemType != null))
     {
         System.Windows.Forms.Binding binding = GetSelectedValueBinding();
         if (binding != null)
         {
             System.Reflection.PropertyInfo propertyInfo1 = _ItemType.GetProperty(ValueMember);
             binding.NullValue = propertyInfo1.GetValue(GetNullItem(), null);
             if (binding == null)
             {
                 binding.DataSourceNullValue = binding.NullValue;
                 return;
             }
             System.Type type = GetBoundType(binding);
             System.Windows.Forms.BindingMemberInfo bindingMemberInfo = binding.BindingMemberInfo;
             string s = bindingMemberInfo.BindingMember;
             System.Reflection.PropertyInfo propertyInfo2 = type.GetProperty(s);
             object obj = System.Activator.CreateInstance(propertyInfo2.PropertyType);
             binding.DataSourceNullValue = obj;
         }
     }
 }
Пример #21
0
 private bool BindingMemberInfoInDataManager(BindingMemberInfo bindingMemberInfo)
 {
     if (this.dataManager != null)
     {
         PropertyDescriptorCollection itemProperties = this.dataManager.GetItemProperties();
         int count = itemProperties.Count;
         for (int i = 0; i < count; i++)
         {
             if (!typeof(IList).IsAssignableFrom(itemProperties[i].PropertyType) && itemProperties[i].Name.Equals(bindingMemberInfo.BindingField))
             {
                 return(true);
             }
         }
         for (int j = 0; j < count; j++)
         {
             if (!typeof(IList).IsAssignableFrom(itemProperties[j].PropertyType) && (string.Compare(itemProperties[j].Name, bindingMemberInfo.BindingField, true, CultureInfo.CurrentCulture) == 0))
             {
                 return(true);
             }
         }
     }
     return(false);
 }
Пример #22
0
        private BindingManagerBase CreateBindingManager(object data_source, string data_member)
        {
            if (data_member == "")
            {
                if (IsListType(data_source.GetType()))
                {
                    return(new CurrencyManager(data_source));
                }
                else
                {
                    return(new PropertyManager(data_source));
                }
            }
            else
            {
                BindingMemberInfo info = new BindingMemberInfo(data_member);

                BindingManagerBase parent_manager = this[data_source, info.BindingPath];

                PropertyDescriptor pd = parent_manager == null ? null : parent_manager.GetItemProperties().Find(info.BindingField, true);

                if (pd == null)
                {
                    throw new ArgumentException(String.Format("Cannot create a child list for field {0}.", info.BindingField));
                }

                if (IsListType(pd.PropertyType))
                {
                    return(new RelatedCurrencyManager(parent_manager, pd));
                }
                else
                {
                    return(new RelatedPropertyManager(parent_manager, info.BindingField));
                }
            }
        }
Пример #23
0
        private void SetDataConnection(object newDataSource, BindingMemberInfo newDisplayMember, bool force) {
            bool dataSourceChanged = dataSource != newDataSource;
            bool displayMemberChanged = !displayMember.Equals(newDisplayMember);

            // make sure something interesting is happening...
            //
            //force = force && (dataSource != null || newDataSource != null);
            if (inSetDataConnection) {
                return;
            }
            try {
                if (force || dataSourceChanged || displayMemberChanged) {
                    inSetDataConnection = true;
                    IList currentList = this.DataManager != null ? this.DataManager.List : null;
                    bool currentManagerIsNull = this.DataManager == null;

                    UnwireDataSource();

                    dataSource = newDataSource;
                    displayMember = newDisplayMember;

                    WireDataSource();

                    // Provided the data source has been fully initialized, start listening to change events on its
                    // currency manager and refresh our list. If the data source has not yet been initialized, we will
                    // skip this step for now, and try again later (once the data source has fired its Initialized event).
                    //
                    if (isDataSourceInitialized) {

                        CurrencyManager newDataManager = null;
                        if (newDataSource != null && BindingContext != null && !(newDataSource == Convert.DBNull)) {
                            newDataManager = (CurrencyManager)BindingContext[newDataSource, newDisplayMember.BindingPath];
                        }

                        if (dataManager != newDataManager) {
                            if (dataManager != null) {
                                dataManager.ItemChanged -= new ItemChangedEventHandler(DataManager_ItemChanged);
                                dataManager.PositionChanged -= new EventHandler(DataManager_PositionChanged);
                            }

                            dataManager = newDataManager;

                            if (dataManager != null) {
                                dataManager.ItemChanged += new ItemChangedEventHandler(DataManager_ItemChanged);
                                dataManager.PositionChanged += new EventHandler(DataManager_PositionChanged);
                            }
                        }

                        // See if the BindingField in the newDisplayMember is valid
                        // The same thing if dataSource Changed
                        // "" is a good value for displayMember
                        if (dataManager != null && (displayMemberChanged || dataSourceChanged) && displayMember.BindingMember != null && displayMember.BindingMember.Length != 0) {

                            if (!BindingMemberInfoInDataManager(displayMember))
                                throw new ArgumentException(SR.GetString(SR.ListControlWrongDisplayMember), "newDisplayMember");
                        }

                        if (dataManager != null && (dataSourceChanged || displayMemberChanged || force)) {
                            // if we force a new data manager, then change the items in the list control
                            // only if the list changed or if we go from a null dataManager to a full fledged one
                            // or if the DisplayMember changed
                            if (displayMemberChanged || (force && (currentList != this.dataManager.List || currentManagerIsNull))) {
                                DataManager_ItemChanged(dataManager, new ItemChangedEventArgs(-1));
                            }
                        }
                    }
                    this.displayMemberConverter = null;
                }

                if (dataSourceChanged) {
                    OnDataSourceChanged(EventArgs.Empty);
                }

                if (displayMemberChanged) {
                    OnDisplayMemberChanged(EventArgs.Empty);
                }
            }
            finally {
                inSetDataConnection = false;
            }
        }
Пример #24
0
        private void SetDataConnection(object newDataSource, BindingMemberInfo newDisplayMember, bool force)
        {
            bool dataSourceChanged    = dataSource != newDataSource;
            bool displayMemberChanged = !displayMember.Equals(newDisplayMember);

            // make sure something interesting is happening...
            //
            //force = force && (dataSource != null || newDataSource != null);

            if (force || dataSourceChanged || displayMemberChanged)
            {
                // If the source is a component, then hook the Disposed event,
                // so we know when the component is deleted from the form
                if (this.dataSource is IComponent)
                {
                    ((IComponent)dataSource).Disposed -= new EventHandler(DataSourceDisposed);
                }

                dataSource    = newDataSource;
                displayMember = newDisplayMember;

                if (this.dataSource is IComponent)
                {
                    ((IComponent)dataSource).Disposed += new EventHandler(DataSourceDisposed);
                }

                CurrencyManager newDataManager = null;
                if (newDataSource != null && BindingContext != null && !(newDataSource == Convert.DBNull))
                {
                    newDataManager = (CurrencyManager)BindingContext[newDataSource, newDisplayMember.BindingPath];
                }

                if (dataManager != newDataManager)
                {
                    if (dataManager != null)
                    {
                        dataManager.ItemChanged     -= new ItemChangedEventHandler(DataManager_ItemChanged);
                        dataManager.PositionChanged -= new EventHandler(DataManager_PositionChanged);
                    }

                    dataManager = newDataManager;

                    if (dataManager != null)
                    {
                        dataManager.ItemChanged     += new ItemChangedEventHandler(DataManager_ItemChanged);
                        dataManager.PositionChanged += new EventHandler(DataManager_PositionChanged);
                    }
                }

                // See if the BindingField in the newDisplayMember is valid
                // The same thing if dataSource Changed
                // "" is a good value for displayMember
                if (dataManager != null && (displayMemberChanged || dataSourceChanged) && !"".Equals(displayMember.BindingMember))
                {
                    if (!BindingMemberInfoInDataManager(displayMember))
                    {
                        throw new ArgumentException(SR.GetString(SR.ListControlWrongDisplayMember), "newDisplayMember");
                    }
                }

                if (dataManager != null && (dataSourceChanged || displayMemberChanged || force))
                {
                    DataManager_ItemChanged(dataManager, new ItemChangedEventArgs(-1));
                }
            }


            if (dataSourceChanged)
            {
                OnDataSourceChanged(EventArgs.Empty);
            }

            if (displayMemberChanged)
            {
                OnDisplayMemberChanged(EventArgs.Empty);
            }
        }
Пример #25
0
		public void EqualsTest ()
		{
			BindingMemberInfo a = new BindingMemberInfo ("A.B.C");
			BindingMemberInfo b = new BindingMemberInfo ("A.B.C");

			Assert.AreEqual (a, b, "EQUALS1");

			b = new BindingMemberInfo ("A.B");
			Assert.IsFalse (a.Equals (b), "EQUALS2");
		}
Пример #26
0
        /// <summary>
        ///   SetDataConnection.
        /// </summary>
        /// <param name="newDataSource">
        ///   A <b>object</b> value.
        /// </param>
        /// <param name="newDisplayMember">
        ///   A <b>BindingMemberInfo</b> value.
        /// </param>
        /// <param name="force">
        ///   A <b>bool</b> value.
        /// </param>
        private void SetDataConnection(object newDataSource, BindingMemberInfo newDisplayMember, bool force)
        {
            if (this.BindingContext == null) return;

            ISupportInitializeNotification dataSource = newDataSource as ISupportInitializeNotification;
            _manager = (CurrencyManager)this.BindingContext[dataSource];
            _manager.ItemChanged += new ItemChangedEventHandler(Manager_ItemChanged);
            _manager.PositionChanged += new EventHandler(Manager_PositionChanged);
        }
Пример #27
0
        /// <summary>
        /// Helper function that sets the displayMemberProperty member based on the DataSource and the provided displayMember field name
        /// </summary>
        private void InitializeDisplayMemberPropertyDescriptor(string displayMember)
        {
            if (this.DataManager != null)
            {
                if (String.IsNullOrEmpty(displayMember))
                {
                    this.displayMemberProperty = null;
                }
                else
                {
                    BindingMemberInfo displayBindingMember = new BindingMemberInfo(displayMember);
                    // make the DataManager point to the sublist inside this.DataSource
                    this.DataManager = this.DataGridView.BindingContext[this.DataSource, displayBindingMember.BindingPath] as CurrencyManager;

                    PropertyDescriptorCollection props = this.DataManager.GetItemProperties();
                    PropertyDescriptor displayMemberProperty = props.Find(displayBindingMember.BindingField, true);
                    if (displayMemberProperty == null)
                    {
                        throw new ArgumentException("Field called '" + displayMember + "' does not exist.");
                    }
                    else
                    {
                        this.displayMemberProperty = displayMemberProperty;
                    }
                }
            }
        }
Пример #28
0
 // Constructor.
 public Binding(String propertyName, Object dataSource, String dataMember)
 {
     this.propertyName      = propertyName;
     this.dataSource        = dataSource;
     this.bindingMemberInfo = new BindingMemberInfo(dataMember);
 }
Пример #29
0
        private void InitializeValueMemberPropertyDescriptor(string valueMember)
        {
            if (this.DataManager != null)
            {
                if (String.IsNullOrEmpty(valueMember))
                {
                    this.ValueMemberProperty = null;
                } 
                else
                {
                    BindingMemberInfo valueBindingMember = new BindingMemberInfo(valueMember);
                    // make the DataManager point to the sublist inside this.DataSource
                    this.DataManager = this.DataGridView.BindingContext[this.DataSource, valueBindingMember.BindingPath] as CurrencyManager;

                    PropertyDescriptorCollection props = this.DataManager.GetItemProperties();
                    PropertyDescriptor valueMemberProperty = props.Find(valueBindingMember.BindingField, true);
                    if (valueMemberProperty == null)
                    {
                        throw new ArgumentException(SR.GetString(SR.DataGridViewComboBoxCell_FieldNotFound, valueMember));
                    }
                    else
                    {
                        this.ValueMemberProperty = valueMemberProperty;
                    }
                }
            }
        }
Пример #30
0
		public void CtorSpecialChars ()
		{
			BindingMemberInfo bmi = new BindingMemberInfo (",/';.[]-=!.$%&*~");

			Assert.AreEqual (bmi.BindingMember, ",/';.[]-=!.$%&*~", "CTORSPECIAL1");
			Assert.AreEqual (bmi.BindingPath, ",/';.[]-=!", "CTORSPECIAL2");
			Assert.AreEqual (bmi.BindingField, "$%&*~", "CTORSPECIAL3");
		}
Пример #31
0
        private bool BindingMemberInfoInDataManager(BindingMemberInfo bindingMemberInfo) {
            if (dataManager == null)
                return false;
            PropertyDescriptorCollection props = dataManager.GetItemProperties();
            int propsCount = props.Count;

            for (int i = 0; i < propsCount; i++) {
                if (typeof(IList).IsAssignableFrom(props[i].PropertyType))
                    continue;
                if (props[i].Name.Equals(bindingMemberInfo.BindingField)) {
                    return true;
                }
            }

            for (int i = 0; i < propsCount; i++) {
                if (typeof(IList).IsAssignableFrom(props[i].PropertyType))
                    continue;
                if (String.Compare(props[i].Name, bindingMemberInfo.BindingField, true, CultureInfo.CurrentCulture) == 0) {
                    return true;
                }
            }

            return false;
        }
Пример #32
0
        /// <summary>
        /// This is used to initialize the value member property descriptor
        /// </summary>
        /// <param name="valueMember">The value member field</param>
        private void InitializeValueMemberPropertyDescriptor(string valueMember)
        {
            BindingMemberInfo bmi;
            PropertyDescriptor pd;

            if(this.DataManager != null)
                if(String.IsNullOrEmpty(valueMember))
                    valuePropDesc = null;
                else
                {
                    bmi = new BindingMemberInfo(valueMember);
                    this.DataManager = base.DataGridView.BindingContext[dataSource, bmi.BindingPath] as CurrencyManager;
                    pd = this.DataManager.GetItemProperties().Find(bmi.BindingField, true);

                    if(pd == null)
                        throw new ArgumentException(LR.GetString("ExFieldNotFound", valueMember));

                    valuePropDesc = pd;
                }
        }
		private BindingManagerBase CreateBindingManager (object data_source, string data_member)
		{
			if (data_member == "") {
				if (IsListType (data_source.GetType ()))
					return new CurrencyManager (data_source);
				else
					return new PropertyManager (data_source);
			}
			else {
				BindingMemberInfo info = new BindingMemberInfo (data_member);

				BindingManagerBase parent_manager = this[data_source, info.BindingPath];

				PropertyDescriptor pd = parent_manager == null ? null : parent_manager.GetItemProperties ().Find (info.BindingField, true);

				if (pd == null)
					throw new ArgumentException (String.Format ("Cannot create a child list for field {0}.", info.BindingField));

				if (IsListType (pd.PropertyType))
					return new RelatedCurrencyManager (parent_manager, pd);
				else
					return new RelatedPropertyManager (parent_manager, info.BindingField);
			}
		}
 private void SetDataConnection(object newDataSource, BindingMemberInfo newDisplayMember, bool force)
 {
     bool flag = this.dataSource != newDataSource;
     bool flag2 = !this.displayMember.Equals(newDisplayMember);
     if (!this.inSetDataConnection)
     {
         try
         {
             if ((force || flag) || flag2)
             {
                 this.inSetDataConnection = true;
                 IList list = (this.DataManager != null) ? this.DataManager.List : null;
                 bool flag3 = this.DataManager == null;
                 this.UnwireDataSource();
                 this.dataSource = newDataSource;
                 this.displayMember = newDisplayMember;
                 this.WireDataSource();
                 if (this.isDataSourceInitialized)
                 {
                     CurrencyManager manager = null;
                     if (((newDataSource != null) && (this.BindingContext != null)) && (newDataSource != Convert.DBNull))
                     {
                         manager = (CurrencyManager) this.BindingContext[newDataSource, newDisplayMember.BindingPath];
                     }
                     if (this.dataManager != manager)
                     {
                         if (this.dataManager != null)
                         {
                             this.dataManager.ItemChanged -= new ItemChangedEventHandler(this.DataManager_ItemChanged);
                             this.dataManager.PositionChanged -= new EventHandler(this.DataManager_PositionChanged);
                         }
                         this.dataManager = manager;
                         if (this.dataManager != null)
                         {
                             this.dataManager.ItemChanged += new ItemChangedEventHandler(this.DataManager_ItemChanged);
                             this.dataManager.PositionChanged += new EventHandler(this.DataManager_PositionChanged);
                         }
                     }
                     if (((this.dataManager != null) && (flag2 || flag)) && (((this.displayMember.BindingMember != null) && (this.displayMember.BindingMember.Length != 0)) && !this.BindingMemberInfoInDataManager(this.displayMember)))
                     {
                         throw new ArgumentException(System.Windows.Forms.SR.GetString("ListControlWrongDisplayMember"), "newDisplayMember");
                     }
                     if (((this.dataManager != null) && ((flag || flag2) || force)) && (flag2 || (force && ((list != this.dataManager.List) || flag3))))
                     {
                         this.DataManager_ItemChanged(this.dataManager, new ItemChangedEventArgs(-1));
                     }
                 }
                 this.displayMemberConverter = null;
             }
             if (flag)
             {
                 this.OnDataSourceChanged(EventArgs.Empty);
             }
             if (flag2)
             {
                 this.OnDisplayMemberChanged(EventArgs.Empty);
             }
         }
         finally
         {
             this.inSetDataConnection = false;
         }
     }
 }
Пример #35
0
        private void SetDataConnection(object newDataSource, BindingMemberInfo newDisplayMember, bool force)
        {
            bool flag  = this.dataSource != newDataSource;
            bool flag2 = !this.displayMember.Equals(newDisplayMember);

            if (!this.inSetDataConnection)
            {
                try
                {
                    if ((force || flag) || flag2)
                    {
                        this.inSetDataConnection = true;
                        IList list  = (this.DataManager != null) ? this.DataManager.List : null;
                        bool  flag3 = this.DataManager == null;
                        this.UnwireDataSource();
                        this.dataSource    = newDataSource;
                        this.displayMember = newDisplayMember;
                        this.WireDataSource();
                        if (this.isDataSourceInitialized)
                        {
                            CurrencyManager manager = null;
                            if (((newDataSource != null) && (this.BindingContext != null)) && (newDataSource != Convert.DBNull))
                            {
                                manager = (CurrencyManager)this.BindingContext[newDataSource, newDisplayMember.BindingPath];
                            }
                            if (this.dataManager != manager)
                            {
                                if (this.dataManager != null)
                                {
                                    this.dataManager.ItemChanged     -= new ItemChangedEventHandler(this.DataManager_ItemChanged);
                                    this.dataManager.PositionChanged -= new EventHandler(this.DataManager_PositionChanged);
                                }
                                this.dataManager = manager;
                                if (this.dataManager != null)
                                {
                                    this.dataManager.ItemChanged     += new ItemChangedEventHandler(this.DataManager_ItemChanged);
                                    this.dataManager.PositionChanged += new EventHandler(this.DataManager_PositionChanged);
                                }
                            }
                            if (((this.dataManager != null) && (flag2 || flag)) && (((this.displayMember.BindingMember != null) && (this.displayMember.BindingMember.Length != 0)) && !this.BindingMemberInfoInDataManager(this.displayMember)))
                            {
                                throw new ArgumentException(System.Windows.Forms.SR.GetString("ListControlWrongDisplayMember"), "newDisplayMember");
                            }
                            if (((this.dataManager != null) && ((flag || flag2) || force)) && (flag2 || (force && ((list != this.dataManager.List) || flag3))))
                            {
                                this.DataManager_ItemChanged(this.dataManager, new ItemChangedEventArgs(-1));
                            }
                        }
                        this.displayMemberConverter = null;
                    }
                    if (flag)
                    {
                        this.OnDataSourceChanged(EventArgs.Empty);
                    }
                    if (flag2)
                    {
                        this.OnDisplayMemberChanged(EventArgs.Empty);
                    }
                }
                finally
                {
                    this.inSetDataConnection = false;
                }
            }
        }
Пример #36
0
		public Binding (string propertyName, object dataSource, string dataMember, bool formattingEnabled, DataSourceUpdateMode dataSourceUpdateMode, object nullValue, string formatString, IFormatProvider formatInfo)
		{
			property_name = propertyName;
			data_source = dataSource;
			data_member = dataMember;
			binding_member_info = new BindingMemberInfo (dataMember);
			datasource_update_mode = dataSourceUpdateMode;
			null_value = nullValue;
			format_string = formatString;
			format_info = formatInfo;
		}
Пример #37
0
        /// <summary>
        /// This is called to check whether or not the binding member info can be found in the data source and is
        /// bindable.
        /// </summary>
        /// <param name="bmi">The binding member info</param>
        /// <returns>True if found, false if not found</returns>
        /// <remarks>A case-sensitive search is tried first.  If that fails, a case-insensitive search is tried.</remarks>
        private bool BindingMemberInfoInDataManager(BindingMemberInfo bmi)
        {
            if(dataManager == null)
                return false;

            PropertyDescriptorCollection pdc = dataManager.GetItemProperties();
            int idx, count = pdc.Count;
            bool found = false;

            // Try case-sensitive first
            for(idx = 0; idx < count; idx++)
                if(!typeof(IList).IsAssignableFrom(pdc[idx].PropertyType) && pdc[idx].Name.Equals(bmi.BindingField))
                {
                    found = true;
                    break;
                }

            // If not there, try for a case-insensitive match
            if(!found)
                for(idx = 0; idx < count; idx++)
                    if(!typeof(IList).IsAssignableFrom(pdc[idx].PropertyType) && String.Compare(pdc[idx].Name,
                      bmi.BindingField, true, CultureInfo.CurrentCulture) == 0)
                    {
                        found = true;
                        break;
                    }

            return found;
        }
Пример #38
0
 private bool BindingMemberInfoInDataManager(BindingMemberInfo bindingMemberInfo)
 {
     if (_DataManager != null)
     {
         PropertyDescriptorCollection itemProperties = _DataManager.GetItemProperties();
         int count = itemProperties.Count;
         for (int i = 0; i < count; i++)
         {
             if (!typeof(IList).IsAssignableFrom(itemProperties[i].PropertyType) && itemProperties[i].Name.Equals(bindingMemberInfo.BindingField))
             {
                 return true;
             }
         }
         for (int j = 0; j < count; j++)
         {
             if (!typeof(IList).IsAssignableFrom(itemProperties[j].PropertyType) && (string.Compare(itemProperties[j].Name, bindingMemberInfo.BindingField, true, CultureInfo.CurrentCulture) == 0))
             {
                 return true;
             }
         }
     }
     return false;
 }
Пример #39
0
        /// <summary>
        /// This is called to get information about the data source and the display member and to hook up the
        /// necessary event handlers.
        /// </summary>
        /// <param name="newDataSource">The new data source.</param>
        /// <param name="newDisplayMember">The new display member in the data source.</param>
        /// <param name="force">True to force the information to be updated, false to only update the info if
        /// something really changed.</param>
        /// <exception cref="ArgumentException">This is thrown if the display member cannot be found in the data
        /// source.</exception>
        private void SetDataConnection(object newDataSource, BindingMemberInfo newDisplayMember, bool force)
        {
            bool dataSourceChanged = dataSource != newDataSource;
            bool displayMemberChanged = !displayMember.Equals(newDisplayMember);

            if(force || dataSourceChanged || displayMemberChanged)
            {
                if(dataSource is IComponent)
                    ((IComponent)dataSource).Disposed -= DataSource_Disposed;

                dataSource = newDataSource;
                displayMember = newDisplayMember;

                if(dataSource is IComponent)
                    ((IComponent)dataSource).Disposed += DataSource_Disposed;

                CurrencyManager cm = null;

                // Touching the BindingContext for the first time creates one and we don't want to come here
                // again yet.
                suppressRefreshItems = true;

                if(newDataSource != null && this.Parent != null && this.BindingContext != null &&
                  newDataSource != Convert.DBNull)
                    cm = (CurrencyManager)this.BindingContext[newDataSource, newDisplayMember.BindingPath];

                suppressRefreshItems = false;

                if(dataManager != cm)
                {
                    if(dataManager != null)
                    {
                        dataManager.ItemChanged -= DataManager_ItemChanged;
                        dataManager.PositionChanged -= DataManager_PositionChanged;
                    }

                    dataManager = cm;

                    if(dataManager != null)
                    {
                        dataManager.ItemChanged += DataManager_ItemChanged;
                        dataManager.PositionChanged += DataManager_PositionChanged;
                    }
                }

                if(dataManager != null && (displayMemberChanged ||dataSourceChanged) &&
                  displayMember.BindingMember.Length != 0 && !this.BindingMemberInfoInDataManager(displayMember))
                    throw new ArgumentException(LR.GetString("ExWrongDisplayMember"));

                if(dataManager != null && (dataSourceChanged || displayMemberChanged || force))
                {
                    DataManager_ItemChanged(dataManager, -1);
                    suppressRefreshItems = true;
                }
            }

            if(dataSourceChanged)
            {
                this.OnDataSourceChanged(EventArgs.Empty);
                suppressRefreshItems = true;
            }

            if(displayMemberChanged)
                this.OnDisplayMemberChanged(EventArgs.Empty);

            suppressRefreshItems = false;
        }
Пример #40
0
 internal BindToObject(Binding owner, Object dataSource, string dataMember) {
     this.owner = owner;
     this.dataSource = dataSource;
     this.dataMember = new BindingMemberInfo(dataMember);
     CheckBinding();
 }
Пример #41
0
 /// <summary>
 /// Called when DataMember property has changed.
 /// </summary>
 /// <param name="oldValue">Old property value</param>
 /// <param name="newValue">New property value</param>
 protected virtual void OnDataMemberChanged(string oldValue, string newValue)
 {
     if (!string.IsNullOrEmpty(newValue))
         _BindingMemberInfo = new BindingMemberInfo(newValue);
     else
         _BindingMemberInfo = new BindingMemberInfo();
     OnPropertyChanged(new PropertyChangedEventArgs("DataMember"));
 }
Пример #42
0
        private void SetDataConnection(object newDataSource, BindingMemberInfo newDisplayMember, bool force)
        {
            bool dataSourceChanged    = dataSource != newDataSource;
            bool displayMemberChanged = !displayMember.Equals(newDisplayMember);

            // make sure something interesting is happening...
            //
            //force = force && (dataSource != null || newDataSource != null);
            if (inSetDataConnection)
            {
                return;
            }
            try {
                if (force || dataSourceChanged || displayMemberChanged)
                {
                    inSetDataConnection = true;
                    IList currentList          = this.DataManager != null ? this.DataManager.List : null;
                    bool  currentManagerIsNull = this.DataManager == null;

                    UnwireDataSource();

                    dataSource    = newDataSource;
                    displayMember = newDisplayMember;

                    WireDataSource();

                    // Provided the data source has been fully initialized, start listening to change events on its
                    // currency manager and refresh our list. If the data source has not yet been initialized, we will
                    // skip this step for now, and try again later (once the data source has fired its Initialized event).
                    //
                    if (isDataSourceInitialized)
                    {
                        CurrencyManager newDataManager = null;
                        if (newDataSource != null && BindingContext != null && !(newDataSource == Convert.DBNull))
                        {
                            newDataManager = (CurrencyManager)BindingContext[newDataSource, newDisplayMember.BindingPath];
                        }

                        if (dataManager != newDataManager)
                        {
                            if (dataManager != null)
                            {
                                dataManager.ItemChanged     -= new ItemChangedEventHandler(DataManager_ItemChanged);
                                dataManager.PositionChanged -= new EventHandler(DataManager_PositionChanged);
                            }

                            dataManager = newDataManager;

                            if (dataManager != null)
                            {
                                dataManager.ItemChanged     += new ItemChangedEventHandler(DataManager_ItemChanged);
                                dataManager.PositionChanged += new EventHandler(DataManager_PositionChanged);
                            }
                        }

                        // See if the BindingField in the newDisplayMember is valid
                        // The same thing if dataSource Changed
                        // "" is a good value for displayMember
                        if (dataManager != null && (displayMemberChanged || dataSourceChanged) && displayMember.BindingMember != null && displayMember.BindingMember.Length != 0)
                        {
                            if (!BindingMemberInfoInDataManager(displayMember))
                            {
                                throw new ArgumentException(SR.ListControlWrongDisplayMember, "newDisplayMember");
                            }
                        }

                        if (dataManager != null && (dataSourceChanged || displayMemberChanged || force))
                        {
                            // if we force a new data manager, then change the items in the list control
                            // only if the list changed or if we go from a null dataManager to a full fledged one
                            // or if the DisplayMember changed
                            if (displayMemberChanged || (force && (currentList != this.dataManager.List || currentManagerIsNull)))
                            {
                                DataManager_ItemChanged(dataManager, new ItemChangedEventArgs(-1));
                            }
                        }
                    }
                    this.displayMemberConverter = null;
                }

                if (dataSourceChanged)
                {
                    OnDataSourceChanged(EventArgs.Empty);
                }

                if (displayMemberChanged)
                {
                    OnDisplayMemberChanged(EventArgs.Empty);
                }
            }
            finally {
                inSetDataConnection = false;
            }
        }
Пример #43
0
		private void SetDataConnection(
			object newDataSource
			, BindingMemberInfo newDisplayMember
			, bool force
			)
		{
			bool flag = _dataSource != newDataSource;
			bool flag2 = !_displayMember.Equals(newDisplayMember);

			if (!_inSetDataConnection)
			{
				try
				{
					if ((force || flag) || flag2)
					{
						_inSetDataConnection = true;
						IList list = (_dataManager != null) ? _dataManager.List : null;
						bool flag3 = _dataManager == null;
						this.UnwireDataSource();
						_dataSource = newDataSource;
						_displayMember = newDisplayMember;
						this.WireDataSource();

						if (_isDataSourceInitialized)
						{
							CurrencyManager manager = null;

							if (((newDataSource != null) && (this.BindingContext != null)) && (newDataSource != Convert.DBNull))
							{
								manager = (CurrencyManager)this.BindingContext[newDataSource, newDisplayMember.BindingPath];
							}

							if (_dataManager != manager)
							{
								if (_dataManager != null)
								{
									_dataManager.ItemChanged -= new ItemChangedEventHandler(this.DataManager_ItemChanged);
									_dataManager.PositionChanged -= new EventHandler(this.DataManager_PositionChanged);
								}

								_dataManager = manager;

								if (_dataManager != null)
								{
									_dataManager.ItemChanged += new ItemChangedEventHandler(this.DataManager_ItemChanged);
									_dataManager.PositionChanged += new EventHandler(this.DataManager_PositionChanged);
								}
							}

							if (((_dataManager != null) && (flag2 || flag)) && (((_displayMember.BindingMember != null) && (_displayMember.BindingMember.Length != 0)) && !this.BindingMemberInfoInDataManager(_displayMember)))
							{
								throw new ArgumentException(res.Argument_WrongDisplayMember, "newDisplayMember");
							}
							if (((_dataManager != null) && ((flag || flag2) || force)) && (flag2 || (force && ((list != _dataManager.List) || flag3))))
							{
								ConstructorInfo ci = typeof(ItemChangedEventArgs).GetConstructor(
									BindingFlags.CreateInstance | BindingFlags.NonPublic | BindingFlags.Instance
									, null
									, new Type[] { typeof(int) }
									, null
								);

								Debug.Assert(ci != null, "ci != null");

								this.DataManager_ItemChanged(
									_dataManager
									, (ItemChangedEventArgs)ci.Invoke(new object[] { -1 })
								);
							}
						}
					}

					if (flag)
					{
						this.OnDataSourceChanged(EventArgs.Empty);
					}

					if (flag2)
					{
						this.OnDisplayMemberChanged(EventArgs.Empty);
					}
				}
				finally
				{
					_inSetDataConnection = false;
				}
			}
		}