// Cannot use one PropertyDescriptor for all owners, because the
		// propertydescriptors might have different Invokees. Check
		// ReflectionPropertyDescriptor.GetInvokee and how it's used.
		//
		public GridEntry (PropertyGrid propertyGrid, PropertyDescriptor[] properties, 
				  GridEntry parent) : this (propertyGrid, parent) 
		{
			if (properties == null || properties.Length == 0)
				throw new ArgumentNullException ("prop_desc");
			property_descriptors = properties;
		}

 public CategoryGridEntry(PropertyGrid ownerGrid, GridEntry peParent, string name, GridEntry[] childGridEntries) : base(ownerGrid, peParent)
 {
     this.name = name;
     if (categoryStates == null)
     {
         categoryStates = new Hashtable();
     }
     lock (categoryStates)
     {
         if (!categoryStates.ContainsKey(name))
         {
             categoryStates.Add(name, true);
         }
     }
     this.IsExpandable = true;
     for (int i = 0; i < childGridEntries.Length; i++)
     {
         childGridEntries[i].ParentGridEntry = this;
     }
     base.ChildCollection = new GridEntryCollection(this, childGridEntries);
     lock (categoryStates)
     {
         this.InternalExpanded = (bool) categoryStates[name];
     }
     this.SetFlag(0x40, true);
 }

        public CategoryGridEntry(PropertyGrid ownerGrid, GridEntry peParent,string name, GridEntry[] childGridEntries)
        : base(ownerGrid, peParent) {
            this.name = name;

#if DEBUG
            for (int n = 0;n < childGridEntries.Length; n++) {
                Debug.Assert(childGridEntries[n] != null, "Null item in category subproperty list");
            }
#endif
            if (categoryStates == null) {
                categoryStates = new Hashtable();
            }

            lock (categoryStates) {
                if (!categoryStates.ContainsKey(name)) {
                    categoryStates.Add(name, true);
                }
            }

            this.IsExpandable = true;
            
            for (int i = 0; i < childGridEntries.Length; i++) {
                childGridEntries[i].ParentGridEntry = this;
            }
            
            this.ChildCollection = new GridEntryCollection(this, childGridEntries);

            lock (categoryStates) {
                this.InternalExpanded = (bool)categoryStates[name];
            }

            this.SetFlag(GridEntry.FLAG_LABEL_BOLD,true);
        }

 public override object GetChildValueOwner(GridEntry childEntry)
 {
     if (!this.mergedPd.PropertyType.IsValueType && ((this.Flags & 0x200) == 0))
     {
         return this.mergedPd.GetValues(this.objs);
     }
     return base.GetChildValueOwner(childEntry);
 }

 internal void CategorizePropEntries()
 {
     if (this.Children.Count > 0)
     {
         GridEntry[] dest = new GridEntry[this.Children.Count];
         this.Children.CopyTo(dest, 0);
         if ((base.PropertySort & PropertySort.Categorized) != PropertySort.NoSort)
         {
             Hashtable hashtable = new Hashtable();
             for (int i = 0; i < dest.Length; i++)
             {
                 GridEntry entry = dest[i];
                 if (entry != null)
                 {
                     string propertyCategory = entry.PropertyCategory;
                     ArrayList list = (ArrayList) hashtable[propertyCategory];
                     if (list == null)
                     {
                         list = new ArrayList();
                         hashtable[propertyCategory] = list;
                     }
                     list.Add(entry);
                 }
             }
             ArrayList list2 = new ArrayList();
             IDictionaryEnumerator enumerator = hashtable.GetEnumerator();
             while (enumerator.MoveNext())
             {
                 ArrayList list3 = (ArrayList) enumerator.Value;
                 if (list3 != null)
                 {
                     string key = (string) enumerator.Key;
                     if (list3.Count > 0)
                     {
                         GridEntry[] array = new GridEntry[list3.Count];
                         list3.CopyTo(array, 0);
                         try
                         {
                             list2.Add(new CategoryGridEntry(base.ownerGrid, this, key, array));
                             continue;
                         }
                         catch
                         {
                             continue;
                         }
                     }
                 }
             }
             dest = new GridEntry[list2.Count];
             list2.CopyTo(dest, 0);
             StringSorter.Sort(dest);
             base.ChildCollection.Clear();
             base.ChildCollection.AddRange(dest);
         }
     }
 }

 internal SingleSelectRootGridEntry(PropertyGridView gridEntryHost, object value, GridEntry parent, IServiceProvider baseProvider, IDesignerHost host, PropertyTab tab, PropertySort sortType) : base(gridEntryHost.OwnerGrid, parent)
 {
     this.host = host;
     this.gridEntryHost = gridEntryHost;
     this.baseProvider = baseProvider;
     this.tab = tab;
     this.objValue = value;
     this.objValueClassName = TypeDescriptor.GetClassName(this.objValue);
     this.IsExpandable = true;
     base.PropertySort = sortType;
     this.InternalExpanded = true;
 }

 protected virtual void Dispose(bool disposing) {
     if (disposing) {
         if (owner != null && entries != null) {
             for (int i = 0; i < entries.Length; i++) {
                 if (entries[i] != null) {
                     ((GridEntry)entries[i]).Dispose();
                     entries[i] = null;
                 }
             }
             entries = new GridEntry[0];
         }
     }
 }

 public void AddRange(GridEntry[] value) {
     if (value == null) {
         throw new ArgumentNullException("value");
     }
     if (entries != null) {
         GridEntry[] newArray = new GridEntry[entries.Length + value.Length];
         entries.CopyTo(newArray, 0);
         value.CopyTo(newArray, entries.Length);
         entries = newArray;
     }
     else {
         entries = (GridEntry[])value.Clone();
     }
 }                                       

        internal SingleSelectRootGridEntry(PropertyGridView gridEntryHost, object value, GridEntry parent, IServiceProvider baseProvider, IDesignerHost host, PropertyTab tab, PropertySort sortType)
        : base(gridEntryHost.OwnerGrid, parent) {
            Debug.Assert(value != null,"Can't browse a null object!");
            this.host = host;
            this.gridEntryHost = gridEntryHost;
            this.baseProvider = baseProvider;
            this.tab = tab;
            this.objValue = value;
            this.objValueClassName = TypeDescriptor.GetClassName(this.objValue);

            this.IsExpandable = true;
            // default to categories
            this.PropertySort = sortType;
            this.InternalExpanded = true;
        }

 protected GridEntry(PropertyGrid owner, GridEntry peParent)
 {
     this.parentPE = peParent;
     this.ownerGrid = owner;
     if (peParent != null)
     {
         this.propertyDepth = peParent.PropertyDepth + 1;
         this.PropertySort = peParent.PropertySort;
         if (peParent.ForceReadOnly)
         {
             this.flags |= 0x400;
         }
     }
     else
     {
         this.propertyDepth = -1;
     }
 }

 public void AddRange(GridEntry[] value)
 {
     if (value == null)
     {
         throw new ArgumentNullException("value");
     }
     if (base.entries != null)
     {
         GridEntry[] array = new GridEntry[base.entries.Length + value.Length];
         base.entries.CopyTo(array, 0);
         value.CopyTo(array, base.entries.Length);
         base.entries = array;
     }
     else
     {
         base.entries = (GridEntry[]) value.Clone();
     }
 }

 internal override bool NotifyChildValue(GridEntry pe, int type)
 {
     bool flag = false;
     IDesignerHost designerHost = this.DesignerHost;
     DesignerTransaction transaction = null;
     if (designerHost != null)
     {
         transaction = designerHost.CreateTransaction();
     }
     try
     {
         flag = base.NotifyChildValue(pe, type);
     }
     finally
     {
         if (transaction != null)
         {
             transaction.Commit();
         }
     }
     return flag;
 }

 internal ImmutablePropertyDescriptorGridEntry(PropertyGrid ownerGrid, GridEntry peParent, PropertyDescriptor propInfo, bool hide)
 : base(ownerGrid, peParent, propInfo, hide) {
 }

 public override void PaintValue(object val, Graphics g, Rectangle rect, Rectangle clipRect, GridEntry.PaintValueFlags paintFlags)
 {
     base.PaintValue(val, g, rect, clipRect, paintFlags & ~GridEntry.PaintValueFlags.DrawSelected);
     if (base.parentPE.GetChildIndex(this) > 0)
     {
         g.DrawLine(SystemPens.Control, (int) (rect.X - 2), (int) (rect.Y - 1), (int) (rect.Width + 1), (int) (rect.Y - 1));
     }
 }

 internal PropertyDescriptorGridEntry(PropertyGrid ownerGrid, GridEntry peParent, System.ComponentModel.PropertyDescriptor propInfo, bool hide) : base(ownerGrid, peParent)
 {
     this.parensAroundName = 0xff;
     this.activeXHide = hide;
     this.Initialize(propInfo);
 }

 protected virtual void NotifyParentChange(GridEntry ge)
 {
     while (((ge != null) && (ge is PropertyDescriptorGridEntry)) && ((PropertyDescriptorGridEntry) ge).propertyInfo.Attributes.Contains(NotifyParentPropertyAttribute.Yes))
     {
         object valueOwner = ge.GetValueOwner();
         bool isValueType = valueOwner.GetType().IsValueType;
         while ((!(ge is PropertyDescriptorGridEntry) || isValueType) ? valueOwner.Equals(ge.GetValueOwner()) : (valueOwner == ge.GetValueOwner()))
         {
             ge = ge.ParentGridEntry;
             if (ge == null)
             {
                 break;
             }
         }
         if (ge != null)
         {
             valueOwner = ge.GetValueOwner();
             IComponentChangeService componentChangeService = this.ComponentChangeService;
             if (componentChangeService != null)
             {
                 componentChangeService.OnComponentChanging(valueOwner, ((PropertyDescriptorGridEntry) ge).propertyInfo);
                 componentChangeService.OnComponentChanged(valueOwner, ((PropertyDescriptorGridEntry) ge).propertyInfo, null, null);
             }
             ge.ClearCachedValues(false);
             PropertyGridView gridEntryHost = this.GridEntryHost;
             if (gridEntryHost != null)
             {
                 gridEntryHost.InvalidateGridEntryValue(ge);
             }
         }
     }
 }

        internal void CategorizePropEntries() {
            if (Children.Count > 0) {
                
                GridEntry[] childEntries = new GridEntry[this.Children.Count];
                this.Children.CopyTo(childEntries, 0);
                
                if ((this.PropertySort & PropertySort.Categorized) != 0) {


                    // first, walk through all the entires and 
                    // group them by their category by adding
                    // them to a hashtable of arraylists.
                    //
                    Hashtable bins = new Hashtable();
                    for (int i = 0; i < childEntries.Length; i++) {
                        GridEntry pe = childEntries[i];
						Debug.Assert(pe != null);
						if (pe != null) {
							string category = pe.PropertyCategory;
							ArrayList bin = (ArrayList)bins[category];
							if (bin == null) {
								bin = new ArrayList();
								bins[category] = bin;
							}
							bin.Add(pe);
						}
                    }

                    // now walk through the hashtable
                    // and create a categorygridentry for each
                    // category that holds all the properties
                    // of that category.
                    //
                    ArrayList propList = new ArrayList();
                    IDictionaryEnumerator enumBins = (IDictionaryEnumerator)bins.GetEnumerator();
                    while (enumBins.MoveNext()) {
                        ArrayList bin = (ArrayList)enumBins.Value;
                        if (bin != null) {
                            string category = (string)enumBins.Key;
                            if (bin.Count > 0) {
                                GridEntry[] rgpes = new GridEntry[bin.Count];
                                bin.CopyTo(rgpes, 0);
                                try {
                                    propList.Add(new CategoryGridEntry(this.ownerGrid, this, category, rgpes));
                                }
                                catch {
                                }
                            }
                        }
                    }

                    childEntries = new GridEntry[propList.Count];
                    propList.CopyTo(childEntries, 0);
                    StringSorter.Sort(childEntries);
                    
                    ChildCollection.Clear();
                    ChildCollection.AddRange(childEntries);
              }
           }
        }

        internal void UpdateSelection() {

            if (!GetFlag(PropertiesChanged)) {
                return;
            }
            
            if (viewTabs == null) {
                return;
            }
            
            string tabName = viewTabs[selectedViewTab].TabName + propertySortValue.ToString();

            if (viewTabProps != null && viewTabProps.ContainsKey(tabName)) {
               peMain = (GridEntry)viewTabProps[tabName];
               if (peMain != null) {
                   peMain.Refresh();
               }
            }
            else {
               if (currentObjects != null && currentObjects.Length > 0) {
                   peMain = (GridEntry)GridEntry.Create(gridView, currentObjects, new PropertyGridServiceProvider(this), designerHost, this.SelectedTab, propertySortValue);
               }
               else {
                   peMain = null;
               }
   
               if (peMain == null) {
                   currentPropEntries = new GridEntryCollection(null, new GridEntry[0]);
                   gridView.ClearProps();
                   return;
               }
   
               if (BrowsableAttributes != null) {
                   peMain.BrowsableAttributes = BrowsableAttributes;
               }

               if (viewTabProps == null) {
                    viewTabProps = new Hashtable();
               }
               
               viewTabProps[tabName] = peMain;
            }

            // get entries.
            currentPropEntries = peMain.Children;
            peDefault = peMain.DefaultChild;
            gridView.Invalidate();
        }

 internal void OnSelectedGridItemChanged(GridEntry oldEntry, GridEntry newEntry) {
     OnSelectedGridItemChanged(new SelectedGridItemChangedEventArgs(oldEntry, newEntry));
 }

 /// <include file='doc\GridEntry.uex' path='docs/doc[@for="GridEntry.NotifyChildValue"]/*' />
 /// <devdoc>
 /// Sends a notify message to the child GridEntry, and returns the success result
 /// </devdoc>
 internal virtual bool NotifyChildValue(GridEntry pe, int type) {
     
     return pe.NotifyValueGivenParent(pe.GetValueOwner(),type);
 }