Version 4.x and up is compatible with .Net 6 and up
- A .Net 7 assembly is now provided.
- Fluent API has been improved to be more intuitive when defining categories and child properties. See the ForCategory method in the documentation.
- The licensing engine has been fixed so that the licensing also works with Smart FieldPackEditor for .Net 6.
- Fluent API got some new property configuration options.
- Fluent API event handler actions that were receiving a property as parameter now receive the argument of the event.
- In the PropertyValueAttributesNeeded event handler, if an EditorAttribute is assigned to a property, then there is a crash when switching to the sorted view.
Initial release for .Net 6.
- There is a new Fluent API to externally configure properties of the grid when SelectedObject is used.
- SelectedObjectChanging event handler has new params: the previous selected objects and the new ones.
- DefaultSelectedPropertyAttribute has been added so that it's possible to define the property that will be initially selected when the grid is filled (by attaching the attribute to this property). This has the same effect as using DefaultPropertyAttribute attached on the target class.
- CollectionPropertySelectorAttribute has been added. By attaching it to a property, this property behaves as the index (in a list) or the key (in a dictionary) of a selected item in a related collection.
- If the toolbar is visible, ensure that the grid has the focus, not the toolbar, when the grid is made visible.
- Samples are now on github.
- There is a crash when the grid is empty and the user is typing a character handled by InternalGrid.OnKeyPress like * or /.
Version 3.x is compatible with .Net 2 to 4.x
- In the PropertyValueAttributesNeeded event handler, if an EditorAttribute is assigned to a property, then there is a crash when switching to the sorted view.
- Library added as a package on nuget.org.
- Version number changed to correspond to what nuget expects.
- Samples are now on github.
- When a property is using an IconEditor (UITypeEditor) and the icon has a size smaller than the small rectangle that displays it, the icon is drawn on the left of the PropertyGrid.
- When the PropertyGrid is hosted in a 3rd party container (tested with an Infragistics container), an unhandled exception may happen when selecting a property using autocomplete mode.
- A lot of visual lag happens when setting a very long text in a multiline editor and scrolling when this property is selected.
- When using SelectedObject, a better exception message is thrown if the PropertyDescriptors of the target instance don't have GetHasCode methods returning unique values.
- A divide by 0 exception could happen on certain readonly values when typing a key in their textbox.
- When the grid is in TabKey mode with TabKeyWithAutoFocus set, it is not possible to resize the columns with a click on the separation line next to the currently active property.
- OnMouseWheel is not called in the grid, preventing the client app to override the default behaviour. This method is now called every time, except when some values can be cycled in the active property.
- On a Property with different values (an enum for instance), it is now possible to cycle between different values beginning by the same letter, just by typing this letter several times, like in the MS PropertyGrid.
- PropertyValidatorBase does not contain a reference to a PropertyEnumerator. This enumerator is passed to its Check method instead.
- A reference to the target instance is incorrectly kept after entering an invalid value in an inplace editor, preventing correct garbage collection of the target instance.
- A reference to the target instance is incorrectly kept after using any validator class on any property, preventing correct garbage collection of the target instance.
- When giving the focus to the radio button inplace control, it is not redrawn to show the focus rect around the active selection.
- Alt+F4 is not closing the app when the focus is in some inplace controls.
- The PropertyGrid.CanTakeTabKey method is now protected virtual.
- When the grid is in TabKey mode and TabKeyWithAutoFocus is set, Hitting the Space key on a manually disabled property (to check the checkbox) also opens the combobox of the value if any.
- TabKeyStaySelectedOnChange submode has been added so that the focus can stay in the currently edited property under the TabKey mode. The default behaviour normally jumps to the next editable property.
- When the grid is in TabKey mode and TabKeyWithAutoFocus is set, it is not possible to click the "manually disabled" checkbox of a property if this property was already selected.
- An uncaught exception could happen when a value is changed in a UITypeEditor and the corresponding property is surrounded by a particular arrangement of properties.
- When TabKey and TabKeyWithAutoFocus are used, changing the sort order is not restoring the focus on the inplace control.
- PropertyEnabling event / OnPropertyEnabling method have been added so that it's possible to cancel the change of the Enabled state.
- In a property using the UpDown feel, if there are multiple values for multiple target instances and a DefaultValueAttribute defines the default value as null, a crash occurs when hitting one of the arrow buttons.
- Property with DefaultValueAttribute set is now selected correctly and ensured visible at startup.
- PropertyFontNameLook was not handling multiple values for multiple selected instances well.
- SPG.Net now contains a pure .Net 4 assembly in the distrib folder.
- The private AppendProperty and InsertProperty methods become protected.
- The PropertySelected event should be called when selecting no property in the grid (i.e. when selecting RightBound).
- There was a crash when double clicking a textbox (to change to the next value) if it was triggering a "recreation" of the underlying property.
- WM_PARENTNOTIFY sent to grid when the Textbox inplace control is double clicked.
- PropertyGrid.OnInPlaceCtrlFinishedEdition() made virtual.
- PropertyGrid.DoubleClickCycleMode has been added to choose whether value cycling occurs when double clicking a property label or value.
- It's now possible to set the alignment (left, center or right) of Hyperlink properties label text that extend over a full row.
- There was a crash when trying to edit a font property with multiple values from multiple target instances.
- Tree glyphs can now be painted with the explorer style. Use CustomDrawManager.UseExplorerTreeViewGlyph=true to switch.
- When a property with the Unit look had 2 different values for 2 different target instances, an exception text was displayed instead of blank.
- When a property with a UnitLook had 2 different units for 2 different target instances, the unit value was displayed as an EnumConverter exception text.
- Some modifications have been made to make SPG work with .Net 4.5.
- SPG assembly in the ".Net 2" distrib folder can now be used on a machine where only .Net 4 is installed.
- DisplayMode has a new FlatCustomSort option that allows a custom Property comparer to be set (using the FlatCustomSortComparer property) when displaying the grid without categories.
- The VS2010 SP1 designer could throw an exception when opening a form containing SPG.
- Array children were badly sorted like this: 0,1,10,11,12,....,2,20,21,.....
- The licensing engine used in SPG is now FIPS (Federal Information Processing Standard) compliant.
- The SPG assembly now weighs ~ 650 KB instead of 1.30 MB
- The UITypeEditor uses a multiline textbox if it detects that the row multiplier of the property is greater than 1.
- Contrarily to what happens in MSPG, SPG will always use the dynamic Description, DisplayName and Category values returned by the DescriptionAttibute, DisplayNameAttribute and CategoryAttributes instances attached to your properties. Great for dynamic localization.
- The KeyValuePair struct used by SPG to define displayed values is now public (it was internal) so that you can override PropertyValueDisplayedAsAttribute.DisplayedValues and return your own pairs (can be handy for runtime globalization).
- The new static property on PropInPlaceTextbox, EnterCreatesLineBreak, allows to create line breaks in a multiline textbox without typing Ctrl.
- So far, the masked textbox inplace control needed the mask to be completed to validate. You can now turn this off.
- You can know if a UITypeEditor has been cancelled with the Esc key by casting the IWindowsFormsEditorService you have in your UITypeEditor's EditValue method to ICancelableEditorService and checking the Canceled property.
- It is now possible to configure the way the checkbox and radio button inplace controls react to mouse clicks: the value can be changed by a click on the button only, the button + the value string or the whole row. See PropertyGrid.CheckboxAndRadioButtonClickModes.
- Description attributes have been added for events and properties so that it can be seen in the MS PropertyGrid at DesignTime.
- Large icons were truncated in a dropdown listbox if the height multiplier of the property was greater than 1.
- A commit could be ignored in some circumstances when the grid is hosted under WPF.
- With multiple target instances, a property could be internally recreated with missing attributes.
- A crash was happening when manually adding a child property to a parent property with multiple target instances.
- Calling DisplayMode could lead to a crash depending on the position of the currently selected property.
- The tooltip now uses the Windows theme correctly.
- Tooltip text was not displaying tabs and ampersands.
- Tooltip display code has completely been refactored for exact placements in all situations.
- A crash was happening when closing a dropdown box with Enter or Escape.
- The PropertyValidatorMinMax's Check method could return a wrong value if not used with an integer type.
- A NullReference exception could happen if setting the Font or PropertyVerticalMargin very early in the lifecycle of the grid (from OnCreateControl for example)
- A FeelList property was not taking the grid's highlighted text color into account.
- When multiple targets were selected and a property had a null value for all targets, the displayed value string was blank when setting a specific string for null values.
- When multiple targets were selected and a property had different values for all targets, setting null to all of them (through a dropdown where a string is associated to null) had no effect.
- The PropertyUnitLook was truncating (by one pixel) letters with a "descent" part (like 'p' and 'g').
- The dropdown container used by UITypeEditors had the wrong back color. This could be an issue when the inner control was not filling the container.
- When using SelectedObject and custom sort, the first displayed property could be the wrong one (not the first one) and the scrollbar was not even reflecting this.
- When deleting a property above the top displayed property while the scrollbar is visible, a crash was occurring.
- Because of the obfuscator, enum properties of the PropertyGrid were wrongly serialized in a form's InitializeComponent method even if equal to their default value.
- When using multiple target instances, a common property to all targets could be missing if it was using the PropertyValueDisplayedAsAttribute.
- The PropertyChanged event was not sent when resetting a property with the Delete key (this property must have a DefaultValueAttribute set).
- The serial number requested at design-time has a new format.
- PropertyGrid.HideCategoriesMode allows to hide empty root categories or the last non empty remaining root category.
- Exceptions raised by the property get accessor methods in the client code were not handled, thus showing a big red X on the grid. SPG now handles them and displays the exception message when feasible.
- Two new events have been added (and corresponding overridable methods): MouseEnterProperty and MouseLeaveProperty, so that you always know where your mouse is (drawing a live "hover" effect is one application, see the left grid in the updated sample).
- The checkbox inplace control (and its look class) accepts a flagged enumeration of type long.
- The OnMouseDown, OnMouseUp and OnMouseMove methods of the grid (and corresponding event handlers) receive a SPGMouseEventArgs type argument containing the property being clicked, its bounding rectangle and its hit test.
- The ParenthesizePropertyName attribute is now taken into account.
- The text of a full width button can now be changed through PropertyFullWidthButtonLook.ButtonText.
- An hyperlinked property with no feel can now be clicked without having to press CTRL.
- The PropertyComparerCatSortPropNoSort comparer class has been added. It allows the properties to be unsorted inside alpha-sorted categories.
- The event LabelColumnWidthRatioChanged has been added to know when the label column width changes.
- The attribute PropertyValueImageListHiddenIndicesAttribute has been added so that it's possible to hide some icons of an imagelist attached to a PropertyValue.
- Collection properties using a checkbox look had to be exclusively an ArrayList. They can now also be a subclass of an ArrayList.
- PropertyChangingEventArgs has now a Cancel property so that you can prevent the grid to commit a new value.
- The PropertyChanging event handler can now override the value to be set.
- PropertyGrid.AcceptsReturn has been added. When true (default), the Return key selects the property value. When false, it has no effect on the grid and it could process the default button of the container form.
- When ShowDefaultValues is set to true, only regular and bold fonts were used. You can now manually set other font styles to a property value and it will correctly be OR'ed with bold.
- It is now possible to reverse the up/down and pageup/pagedown keys on a trackbar (the default behavior of the trackbar is a design flaw). Use the property PropInPlaceTrackbar.ReverseUpDownKeys or the TrackBarSettingsAttribute class.
- PropertyValue has a new ScrollValueOnTextboxDoubleClick property to prevent its value to be changed when a double click occurs on a textbox (this happens if a set of standard values has been published). It can also be done through the ScrollValueOnTextboxDoubleClickAttribute.
- The value of a non boolean property with only 2 possible values displaying a single checkbox was not modified when double clicking on the label of the property.
- When saving/restoring the states of properties (when a property is internally recreated for example), the image index for the label icon was not saved.
- HitTest was returning "Client" instead of "Value" when the mouse was over the value part of a root category or subcategory displaying a "value text" or when the drawing manager displays a vertical line between the label and value columns.
- For a non boolean property having 2 possible values with a single checkbox, the tooltip text and location were wrong.
- When using the mouse wheel, if a tooltip had to be displayed for a new property landing under the mouse, the wrong tooltip text or no tooltip at all was displayed.
- Changing LeftColumnWidth was not resizing the current inplace control if any.
- When switching from categorized to a flat display mode, invisible properties were displayed.
- When setting SelectedObject to null, the previous selected target instance was not garbage collected if GC.Collect() was called. This was happening only if an inplace control had been displayed.
- A crash could happen when clicking with the middle mouse button inside a dropdown list, if the mouse driver was trying to display the small circular icon with the up and down arrows inside (usually seen in office and IE).
- ICustomTypeDescriptor.GetDefaultProperty() was not taken into account to initially select a property.
- If the font of the grid was initially the one of its parent (because of the ambient properties behaviour) and the font you set on the parent is bigger than the .Net default font, the basic property height was calculated based on the .Net default font and not on the one set on the parent. This could produce a big font inside a tiny property row.
- Typing a mnemonic key while a property label is selected was activating the mnemonic. It now correctly dispatches the key to the inplace control if any.
- PropertyFullWidthButtonLook was not using the drawing manager to draw the button.
- With Vista and up, the vertical scrollbar could flicker (between the theme appearance and the old classic look) in various circumstances.
- In one specific case, a TypeConverter was receiving a null property enumerator in the PropertyTypeDescriptorContext passed to GetProperties().
- A crash could happen when a value was changed by a dropdown inplace control and the grid was reconstructing the property and its children.
- When the grid was hosted in a WPF WindowsFormsHost container, a MDA exception could be raised when leaving the app under Windows XP.
- There was a bug in AddTargetInstance which could cause a crash when adding manually a third target instance to a property.
- A manually disabled checkbox set to a property was not restored after a call to RestorePropertiesStates.
- Hitting F4 while a UITYpeEditor was visible with a combobox focused was closing the editor but was also opening the combobox.
- A UITypeEditor was privileged over a list of possible values when such an editor was attached to a property with a TypeConverter publishing standard values. To be compatible with the Microsoft PropertyGrid, this is now the contrary. If you want to privilege a UITypeEditor, attach the ForceEditorAttribute to your property or type.
- IInPlaceControl.OwnerPropertyEnumerator can now receive null as argument. Check your custom inplace controls!
- PropertyValue.SetValueFromInPlaceCtrl now takes the new value to be set as a ref so that the PropertyChanging event handler could override the value.
- With Smart FieldPackEditor, the PropertyGrid can show a totally new dropdown MonthCalendar for dates. It is localizable and can show Today and Clear buttons.
- The PropertyGrid.PropertyLabelBackColor and PropertyGrid.PropertyValueBackColor properties have been added to easily change the background of both columns in one shot.
- The PropertyGrid.AppendVariable() and InsertVariable() methods have been added to create properties targetting public variables.
- To move the PropertyGrid in the designer, you can now click anywhere in its bounds. Previously, you were obliged to click on the small top/left move icon.
- The PropertyGrid.ExpandAllMaxLevels property has been added to change the default maximum number of levels expanded under a single property when ExpandAllProperties is called.
- The static member variable PropInPlaceList.MinDropDownHeight has been added to allow you to increase the height of long lists in the dropdown part of the list inplace control.
- The static member variable PropInPlaceList.MaxDropDownWidth has been added to allow you to lower the width of large lists in the dropdown part of the list inplace control.
- The PropertyDescriptors property has been added to the PropertyValue class so that you can access every PropertyDescriptor of every target instance when SelectedObjects is used.
- The PropertyFeel.IsUITypeEditorBased virtual property has been added so that you can create a custom feel that works with a UITypeEditor (drawing of the property will be done by the editor).
- For properties with a DefaultValue attribute, the Delete key now restores the default value when pressed in a readonly textbox (behaves like in MSPG).
- The DefaultProperty attribute is now handled by the grid.
- The PropertySelecting and PropertyExpanding events (and corresponding On... virtual methods) have been added. By setting the Handled property of the event argument to true, you can stop the normal processing of the user actions (expand/collapse, selection).
- The checkbox look/feel now accepts any type with 2 possible published values. It then behaves as a single boolean checkbox.
- The ValueValidation event now fires when an exception occurs in a UITypeEditor's EditValue method. The client application can display a popup if needed.
- A checkbox inplace control (and its look class) accepts a flagged enumeration of type long.
- In RTL mode, dropdown UITypeEditors could not appear.
- In RTL mode, dropdown lists (list feels) were not left aligned with the property value.
- Dropdown lists (list feels) could be truncated on the right of the screen.
- In RTL mode, HitTest was not working for hyperlinks
- Various issues (mainly cosmetic) have been fixed when SPG is used from MFC code.
- At design-time, the columns widths (through the LabelColumnWidthRatio property) could be set differently than what was specified in the designer PropertyGrid.
- The handling of the Font as an ambiant property was not correct, i.e. setting the Font on the parent of the grid was not correctly inherited. Furthermode, the AutoScaleMode was not set, leading to a weird resizing behavior when modifying the font of the parent.
- There was a missing graphics.Dispose() call in the Trackbar inplace control.
- When the dropdown form of a UITypeEditor or List feel is visible, the Application.Idle event won't be fired (this is true in the Microsoft PropertyGrid too). SPG fixes that by reenabling this event if needed (set PropertyGrid.HandleIdleDuringDropDown to true).
- When closing a dropdown editor by double-clicking on another property, the value could be modified on the currently selected property which had the UITypeEditor opened, not the one double-clicked. This is fixed by not allowing a change on any of them.
- Using the PropertyComparerNoSort was removing some properties of the grid when targetting multiple instances.
- There was a crash when switching from flat to categorized display mode and a multiline property was partially visible at the top.
- When clicking on a property value of an unselected property, the mouse click was not propagated to the actual control of the inplace control under the mouse if there was more than one level of children.
- There was some problems with textbox autocompletion under Vista.
- Regression: in tabkey + autofocus mode, the text in an inplace control with a textbox was not selected anymore when selecting a property.
- Regression: a textbox with a password look was assigning the password mask in the target property instead of the hidden text.
- The Property and PropertyValue Tag properties were not saved and restored when the grid was recreated (with a call to RefreshProperties for instance).
- The checkbox inplace control was not reporting validation errors to the grid (occuring when the property set accessor is throwing an exception).
- When LazyLoading was set to true and SPG was used in non categorized mode, expanding and collapsing several times a property with manually added children was multiplying the number of children.
- When LazyLoading was set to true and SPG was used in non categorized mode, expanding a property and deleting one of its child properties from the PropertyCreated event handler was crashing.
- When using SelectedObjects, calling PropertyValue.ResetToDefaultValue() was only handling a single target instance when calling Reset"PropertyName".
- The dropdown list uses now the HeightMultiplier of the property to size and draw itself.
- When using the updown buttons on a property with a minmax validator, if the new value was beyond the limits, SPG was not forcing it to the min or max value.
- There was a crash when trying to dispose the grid while a dropdown editor was displayed.
- It was not possible to reliably show a validation tooltip on a property with a checkbox look/feel.
- When autocompletion was active in a textbox, typing the beginning of a possible value with a different case was forcing the case to the one of the possible value.
- In the checkbox inplace control, BeginCommitChanges and EndCommitChanges were not always triggered by pair.
- The size of the dropdown holder for UITypeEditors could be wrong in several circumstances.
- Setting ReadOnly to true on a property with an active inplace control and with a look having NoFeelForReadOnly set to true was not hiding the inplace control.
- In tab key mode, selecting a new unit in the unit inplace control was not sending the right property enumerator to the PropertyChanged event handlers.
- In several attributes of the SPG framework, Equals was not correctly implemented. In this circumstance, testing the Attributes collection (of a PropertyDescriptor for instance) against a specific attribute could fail (ex: Attributes.Matches(ReadOnlyAttribute.Yes)).
- MouseWheeling while in a property Value could result in a crash on x64 OS.
- In tab key mode, hitting Shift+Tab while on the first property could lead to a crash in some circumstances (depending on how the properties are setup with their visibility status at the end of the grid).
- The DisplayedValuesNeeded event can be triggered each time the dropdown window of a List feel is requested by the user. This is done with the new PropertyValue.ResetDisplayedValues(ResetDisplayedValuesTriggerMode) override.
- PropertyGrid.GetPropertyHashCode can be passed a flagged enumeration code to control what elements to include in the hashcode.
- The static variable AutoCompletionTimerDuration has been added to the PropertyGrid class so that you can change the duration used to reset the autocompletion buffer to empty after a key has been pressed.
- Autocompletion is switchable on/off on each property value.
- Performance has been increased when SPG is used with a large number (thousands) of target instances.
- The PropertyProgressLook class was only accepting integers. It now accepts all numeric types.
- The grid was not getting the properties of a target instance if this instance was a wrapping TypeDescriptor without a TypeConverter to inform about subproperties.
- In the trackbar inplace control, the width of the textbox is calculated differently in order to avoid an occasional problem where the width is far too large.
- The calculation of a Property hashcode (in PropertyGrid.GetPropertyHashCode) had an error which could have a consequence in certain circumstances.
- In RTL mode, the dropdown button was reopening the dropdown box when clicked while the box was already open. It was also opening the box if the property was not selected yet (clicking on it while not selected).
- With the C++ compiler, the AttributeUsage attached to the PropertyAndChildrenAttribute class is not detected on subclasses, preventing to attach multiple instances of the same attribute to a property. The AttributeUsageAttribute has been restored on each child attribute.
- If a look class was specifying the bounds of the displayed string, some inplace control were not always respecting it.
- When adding a property to a disabled parent property, the new one was not set as disabled.
- The child properties of a parent property linked to a structure were not updated correctly if the structure was changed externally to SPG.
- The readonly state of properties was not always correct.
- The width of the columns was changing when the scrollbar needed to be shown (from an invisible state) or hidden (from a visible state).
- A VK_RETURN keystroke was generated when double clicking the label of a readonly property.
- The client application was not being notified for the key events of the PropInPlaceUITypeEditor class.
- With an updown inplace control, if the current value was equal to the minimum or maximum value of the underlying data type, hitting the down arrows was throwing an Overflow exception.
- The internal grid was not repositioned when the toolstrip's height was manually changed.
- The mouse wheel code was not using the SystemInformation.MouseWheelScrollLines information (set in the mouse driver by the user) to scroll the grid.
- Clipboard pasting could result in an invalid value in a non textbox based inplace control.
- In the Radio button inplace control, moving the mouse wheel was unexpectedly changing the selected radio button instead of just changing the focus cue.
- When using a SortedCategory attribute and a custom PropertyDescriptor overriding the Category property at the same time, the category name was grabbed from the attribute instead of the PropertyDescriptor.
- The PropertyFeelAttribute and PropertyLookAttribute classes were not detected when attached to a type instead of a property.
- In tabkey mode with autofocus submode set, clicking on the +/- glyph of an already selected category/property had no effect.
- After opening a resizable dropdown UITypeEditor, opening another non resizable UITypeEditor was setting its size incorrectly.
- The PropertyFontNameLook was displaying the value incorrectly in RightToLeft mode.
- The tooltip display was corrupted if larger than the screen (regression introduced in 3.0).
- When a TypeConverter publishes the properties of the target instance, the context passed to the GetProperties(Supported) methods was missing the Instance parameter.
- PropertyValue.ResetDisplayedValues(bool) is now obsolete. Use PropertyValue.ResetDisplayedValues(ResetDisplayedValuesTriggerMode) instead.
- SPG supports right to left languages.
- SPG supports lazy loading (PropertyGrid.LazyLoading = true). It increases performance for large contents and solves the cyclic properties issue.
- SPG can now display an icon in front of any property value.
- Incremental search (typing letters one by one to get to the searched string) has been added to every textbox of properties having multiple displayed values (.Net 2.0+) and to the dropdown form of the list feel. It has even been added to listboxes found in external UITypeEditors i.e. you can type color or cursor names to find the one you want in the list.
- PropertyGrid.ShowDefaultValues uses DefaultValue attributes and ShouldSerialize methods to alter the font of the property values.
- The AlphaColorPicker class is now easily derivable and its alpha component can be turned off.
- The ResetDisplayedValues method and the DisplayedValuesNeeded event accept null strings in order to remove a possible value from the ones published by a TypeConverter. This is useful for enumerations for example in which you can now dynamically remove fields.
- The Editor and TypeConverter attributes can be set on a property at any time after the property has been created (with the PropertyValue.SetAttribute method).
- .Net 2.0+: The checkbox look and inplace control classes now support a nullable boolean type to create a 3-states checkbox (the undefined state can have its own string). It is possible to prevent the undefined state to be selected by the end-user.
- The PropertyGrid.ExpandAllProperties method can take a property enumerator in argument so that only the properties browsed by this enumerator will be expanded/collapsed.
- The '*' key expands all properties under the selected property (with a maximum depth of 10 to avoid infinite cycling). The '/' key collapses all properties under the selected property.
- The GetValueBackgroundColor virtual method has been added to the drawing manager class. It allows you to dynamically vary the value background color based on some criteria like the presence of multiple values for example.
- Tooltip is now ownerdrawn and can display italic fonts without truncation.
- When a property has an empty string in its possible displayed values, hitting Delete or Backspace when its label or inplace control is selected will select the empty displayed value.
- UpDownSettingsAttribute class has been added so that at designtime it's possible to set the increment of a property that uses the UpDown feel.
- PropertyDropDownContentAttribute can take additional arguments to be passed to the IDropDownContent implementation.
- A dropdown form (implementing IDropDownContent) can now close itself by calling it's parent's (PropInPlaceContainer) CloseDropDown method.
- PropertyGrid.ShowAdditionalIndentation creates an indentation more similar with the one of the Microsoft PropertyGrid.
- The PropertyGrid.AdjustComments method has been added to make the height of the comments area fit the test to be displayed.
- The button and UITypeEditor inplace controls can now display the button on the full width of the value column (use the FullWidthButton property). A ButtonSettingsAttribute class also allows to set this property at design-time. At last, a PropertyFullWidthButtonLook class has been added to ensure the button is always displayed on the property value.
- Focus rectangles on updown and combobox inplace controls (those without a textbox) are better adjusted.
- When a property was disabled because it was readonly, calling PropertyValue.Recreate on this property was forcing all child properties to be disabled too. This was not correct in a lot of cases.
- The rectangle painted by the UITypeEditor.PaintValue method now respects the left margin (returned by PropertyGrid.GlobalTextMargin).
- Regression bug under .Net 1.1: non browsable properties (BrowsableAttribute set to false) were still visible in the grid.
- Depending on the font, the bullets displayed by the password look could be shifted by one pixel.
- When double-clicking the label of a property with an updown feel, the textbox was focused and the text was selected, which was not consistent with the other inplace control types.
- Checkboxes and radio buttons were not displayed in a disabled state when the grid was disabled.
- The ITypeDescriptorContext.Instance property was not always set correctly.
- It was not possible to set multiple TrackBarSettingsAttribute on a property for several children.
- PropertyValue.TypeConverter could return a brand new TypeConverter instead of relying on the one already owned by a PropertyDescriptor.
- Setting a PropertyIdAttribute on some but not all of the properties could result in various issues. SPG now ensures that two sibling properties won't have the same id in this case.
- The default alphabetical sort (controlled by the PropertyComparerDefaultSort class) could be wrong on property level > 1 if various Category attributes were applied to the sibling child properties of a parent property.
- SPG was crashing when removing the default buttons of the toolbar and calling PropertyGrid.DisplayMode.
- The MouseLeave event was not reported to a PropertyGrid derived class.
- When switching the display mode, the selected property tries to keep its position.
- There could be a crash in a trackbar inplace control if the trackbar becomes too small after resizing the grid (or the value column).
- The PropertyLook.OnDraw and PropertyValue.DrawValue methods take an additional argument to know where the value is actually drawn.
- The PropertyValue.Recreate method has been replaced by the PropertyGrid.RecreateProperty method. The difference is that, before, only child properties were recreated. Now the property is actually deleted and completely recreated with the same logic than at its first creation.
- PropertyGrid.HitTest can now return Nowhere.
- The SelectedIndex that was passed in the PropertyChangedEventArgs has been removed. You can now access this information through PropertyValue.SelectedDisplayedValueIndex which will now work for any property and any feel using possible displayed values.
- CustomDrawManager.DrawCategoryLabelText and CustomDrawManager.DrawSubCategoryLabelText take an additional argument (the bounds of the whole row).
- Attaching an empty EditorAttribute to a property is now recognized and means "no editor". It allows for example to really force a collection property to be readonly.
- A virtual method GetPropertyHashCode has been added to the PropertyGrid class, so that it's possible for you to override the hashcode calculation used when saving and restoring property states during a grid refresh.
- The property display name and comment passed to AppendProperty-like methods can now be null. In this case, they will be determined from the attributes passed in parameter (.net 1.1 and 2.0+) or from the property descriptor (.net 2.0+).
- When changing the value of a property, the internal Refresh of the grid (if any) is now more performant (it was previously always refreshing the whole grid).
- There was a crash if the TypeDescriptor.GetProperties or TypeConverter.GetProperties method is returning null (while GetPropertiesSupported() is returning true).
- An EditorAttribute set at runtime (with PropertyValue.SetAttribute()) had no effect.
- During a RestorePropertiesStates, usually called after RefreshProperties is finished, restoring the states of some properties whose value type has changed could fail. Therefore, the calculation of the property hashcode has been changed.
- During a RestorePropertiesStates, the selected property could shift to another row.
- During a RestorePropertiesStates, the HeightMultiplier of a property is now restored.
- During a refresh of the grid, if the selected property was recreated, the PropertySelected event could be triggered multiple times.
- If a get accessor of one of your properties was raising an exception, the grid was not catching it and a red cross was displayed.
- A property with a trackbar feel could not be set as readonly without crashing.
- Many fine-tunings on the management of the ReadOnly attribute.
- Regression: the trackbar inplace control was not resized when the width of the grid columns was changed.
- There was a crash when refreshing the content of the grid while the DisplayName of the selected property (or of an ancestor) was changed.
- If the grid was in a collapsible (auto-hide) panel, opening the dropdown list or editor of a property would close it immediately as well as close the panel.
- When changing the PropertyGrid's BorderStyle property, the scrollbar was resetted to position 0 and a bad page count.
- Regression bug: when in TabKey mode, clicking on the dropdown arrow to close the dropdown box of a UITypeEditor was modifying the value of the next property.
- TypeConverter.CanConvertFrom was not always called with a context (when determining if the property must be displayed as readonly).
- There was a crash when typing a key in an inplace control (for list, UITypeEditor, unit and updown feels) to directly choose one of the displayed values while an empty string is one of the possible values.
- If a category or subcategory was hidden in categorized display mode, switching to a flat display mode was revealing all descendant properties of the hidden category.
- When the content (total or part) of the grid was refreshed, hidden properties were reappearing.
- The "manually disabled checkbox" was not working on root categories.
- The dropdown form could not close if its new value was invalid (this was happening with the alpha color picker when choosing a transparent color for a property that could not accept transparent colors).
- Hidden properties were not taken into account when switching to flat mode. Therefore, a deep enumerator was unable to browse them.
- SPG was hanging when calling a set of methods while the grid's height was smaller than one property height. The scrollbar was also incorrectly setup in such a case.
- If a target instance was implementing ICustomTypeDescriptor, the Instance property passed through a ITypeDescriptorContext was referencing the object returned by the ICustomTypeDescriptor.GetPropertyOwner method instead of referencing the ICustomTypeDescriptor itself.
- Under Windows x64, an overflow exception could be raised (and internally caught) while typing keys.
- Regression: values changed in readonly textboxes inside UITypeEditors (by typing the up/down key or the first letter of a value) were not commited.
- A PropertyTypeDescriptorContext was not always passed to the UITypeEditor.GetEditStyle() method.
- Some weird obsolete code has been removed, creating a drastic increase in performance when filling the grid with SelectedObject(s).
- When using a custom PropertyComparer with multiple target instances, the sort order was invariably alphabetical.
- If a property had a ShowChildPropertiesAttribute(true) set, changing the value of the property would not recreate its children (with an obvious effect when changing the value to/from null).
- With an updown inplace control set to RealtimeChange=false, the value was still commited to the target property after the second click on the up/down buttons.
- The UITypeEditorVisualStyleAttribute class has been added so that you can override the button style of the editor.
- HyperLinkPropertyClicked events for hyperlink properties are now always generated (previously you got them only for single clicks).
- The property descriptors published for a collection were alphabetically sorted (e.g. for an array it was sorting the child properties as , , , , , , ...).
- Adding a new property with a DisplayMode different than the Categorized mode now throws an exception instead of just asserting (which was visible just under debug mode).
- A property value of type String could be not updated correctly when edited by a UITypeEditor.
- The UITypeEditorTextBoxVisibility attribute has been added so that it's possible to remove the textbox for a UITypeEditor. A PropertyLook class could draw anything in the space left.
- The PropertyColorLook can draw the color box on the whole value column without the value text.
- The PropertyComparerDefaultSort class now queries the SortedProperty attribute attached to nested child properties. It removes the limitation that the grid was not able to handle the SortedProperty attribute set on child properties.
- A new attribute PreventRefreshProperties can be attached to a property if you want to prevent the RefreshProperties method to be called internally when the property value changes. Do it only if you are sure that the value change should not incur a change in the content of the grid (usually for performance reasons).
- The SetAttribute and DeleteAttribute methods have been added to the PropertyValue class.
- A new PropertyValueAttributesNeeded event has been added (and the related OnPropertyValueAttributesNeeded virtual method) so that custom attributes can be set on a property as soon as its PropertyValue instance has been created.
- The PropertyChanging event has been added. It is triggered just before the target properties are actually updated after the user changed a value in the grid.
- A new ReadOnlyChildProperties attribute enables to force all child properties to be set as readonly.
- A bug in the trackbar inplace control could prevent the trackbar to update the underlying value under certain conditions when RefreshProperties is internally called. An exception could also be raised.
- A realtime AlphaColorPicker could be broken and create a crash if a change of the color by the picker was producing an internal call to RefreshProperties.
- The AlphaColorPicker could not handle multiple values from multiple target instances.
- When creating a property, a TypeConverterAttribute passed as an argument to AppendProperty-like methods was not used while determining its child properties (GetProperties was not called).
- Under Vista, when switching from/to aero theme, all the themed parts in the grid were disappearing.
- There could be a crash when using SelectedObjects and a property was decorated with a MergableProperty attribute set to false.
- A performance issue has been fixed. SelectedObject(s) should be faster to populate the grid especially when there are numerous properties in the grid.
- PropertyDescriptorCollections supplied by TypeConverters or TypeDescriptors could be altered by SPG (during the pre-filtering processing) which is a problem when the client application tries to cache such collections.
- The PropertyGrid.AddTargetInstance (which you can call to add a new target on a manually created property) had a typo/bug preventing to set a common value to a property of multiple target instances.
- If a parent property was set as readonly (by any mean) then the child properties were forced as readonly too. In some cases, this was not correct. It is now enforced only if the parent property has a TypeConverter whose GetCreatetInstanceSupported method returns true.
- PropertyValue.SetValueFromInPlaceCtrl() takes a new argument (string valueKey which corresponds to the key of an additional value attached to the property, like the unit in a Unit feel).
- If a property is ReadOnly, it won't continue to force the child properties to be readonly. There was a bad assumption made by SPG about this subject. If you want to force such behavior in your application you can use the new ReadOnlyChildPropertiesAttribute on the parent property.
- SelectedObjects now allows full edition of immutable properties (the one whose TypeConverter's CreateInstanceSupported returns true) and collections.
- Displayed values (set by PropertyValue.ResetDisplayedValues or by the PropertyValueDisplayedAsAttribute) are more flexible. Before you could only set them as strings. You can now supply objects or pairs <object, string>.
- Trackbars now accept to target integer, float, double and decimal property types.
- Ctrl+Enter in a multiline textbox inserts a new line.
- By default, a listbox uses the same visuals (font, fore and back colors) than the property value. It is now possible to break this synchronization and let the listbox use the normal colors used by the grid. This is done by using the DropDownListboxVisuals attribute.
- The class PropertyComparerNoSort (to be used with PropertyGrid.PropertyComparer, before SelectedObject is called) has been added so that it's possible to have a categorized but non sorted display mode.
- The SelectedObjectChanging event has been added. It is triggered before the target instances are actually changed in the grid.
- The List feel can use a cache for properties showing a costly content that should not be recreated each time the listbox is displayed. To configure a property in such a way, mark it with UseFeelCacheAttribute. The cache can be emptied by setting PropertyValue.FeelCache to null.
- The Unit inplace control now takes into consideration a unit with a single value (a collection with a unique possible value or a simple string). In this case, no dropdown is shown and the value is just displayed as a static information.
- For list feels, the resize box can be removed by setting the PropInPlaceList.PreventResizable to true (from the InPlaceCtrlVisible event handler).
- The AlphaColorPicker dropdown box now takes into account the RealtimeChange property of the PropInPlaceList inplace control to update the property value as soon as there is a mouseup or keyup on the trackbars and Saturation/Brightness map.
- Support for Windows x64.
- SelectedObjects has been reworked and SPG now behaves correctly regarding multiple instances.
- There could be a crash when targetting some non integer enumeration properties (e.g. uint).
- An enumeration like MessageBoxIcon, where several fields have the same value, was not processed correctly. Each value is now displayed once (while the Microsoft PropertyGrid shows duplicates).
- When setting a new color or font on a selected property, the inplace control was not updated according to this new visual attribute.
- If at design-time, you applied your own attribute, derived from an expected attribute like PropertyValueDisplayedAsAttribute, and this base attribute had the AttributeUsage set to AllowMultiple=true, then your attribute could not be found by SPG.
- When closing a dropdown list (FeelList) by clicking on the dropdown arrow, there was a small flickering effect (regression bug).
- Hitting '+' or '-' in a grid with no selected property was causing a crash.
- A PropertyTypeDescriptorContext was not always passed to the UITypeEditor.GetEditStyle() method.
- When double clicking in an empty textbox to get the first value of an enumerable type, the text was selected up to the current position of the mouse instead of being completely selected.
- With a RadioButton inplace control and its RealtimeChange property set to false, a double click on the property label was not cycling the value.
- There was different cases where a crash could occur when trying to hide a category/property with ShowProperty().
- SPG was not able to display correctly an enumeration like MessageBoxIcon where several possible fields have the same numeric value.
- Changing the BackColor of the PropertyGrid was not changing the back color of the toolbar.
- The initial width of the dropdown part of a UITypeEditor could be miscalculated.
- When setting CommentsHeight in the designer, it could be ignored at runtime depending on the size of the grid, even if it was valid.
- The Saturation/Brightness map in the AlphaColorPicker dropdown box could be not repainted the first time it takes focus.
- SelectedObjectChanged now takes a SelectedObjectChangedEventArgs containing a reference to the previous target instances.
- The PropertyGrid.SavePropertiesStates method now takes a boolean argument to indicate if visual attributes (colors and fonts) must be saved or not.
- PropertyLook.OnDraw takes a new last argument (bool multipleTexts) indicating if the property targets multiple instances with multiple texts.
- When setting a new value in a property, only the validator of this property will be checked. Validators for the parent and children won't be checked anymore.
- Usage of PropertyValueDisplayedAsAttribute and PropertyValue.ResetDisplayedValues have been changed. Refer to the documentation.
- The AlphaColorPicker dropdown box now updates the value in realtime because it relies on the RealtimeChange property of the PropInPlaceList control which was set to true by default.
- There was a (regression) crash (in the sample) when closing the app after the MultilineStringEditor had been used.
- There was a crash when the client code was specifying an erroneous EditorTypeName in an EditorAttribute.
- There was a crash when the grid had no ancestor form (this is the case in unmanaged applications for example).
- If a UI created by your UITypeEditor is derived from Form, SPG was not making it visible.
- OnSelectedObjectChanged is now called while the grid is internally in Categorized mode.
- PropertyGrid.RefreshProperties() has been added. It has the same effect as the Microsoft PropertyGrid Refresh() call, i.e. rebuild the content of the grid based on the input of type converters and type descriptors.
- Two helper methods are added: PropertyGrid.SavePropertiesStates and PropertyGrid.RestorePropertiesStates. They allow to save the expanded and selected states of all the properties. This is very convenient to keep the visual aspect of the grid and its properties when you call SelectedObject on the same or on a similar target type.
- In the handler of the PropertySelected event, you can know the property which was previously selected.
- Clipboard operations were not working when a menu with the clipboard entries was present.
- There was a crash when hiding a property with ShowProperty if the first visible property was a descendant of the hidden property.
- There was a crash when trying to set a property as an added value of an existing property (mainly the Unit of a number) if the existing property was at a level greater than 1 (one that is not directly reported by the target instance of SelectedObject).
- Dynamic (thanks to type descriptors and type converters) target instances are now better managed when SelectedObject is used and the content of the grid is rebuilt when needed.
- A regression bug appeared when under .net 1.1, preventing the user to close a dropdown list by clicking outside the list with the mouse.
- When the PropertyGrid was not directly in a form but in a sub-control, the currently edited value in a textbox was lost when clicking outside the application.
- When a UITypeEditor had its dropdown form opened and the user clicked outside the application, the focus cue was not given back to the grid and its inplace control correctly when the application was activated again.
- There was a slight flickering effect (on the textbox part of the inplace control) when typing a first character while the inplace control had not the focus yet.
- When calling SetValue on a PropertyValue, there was no automatic refresh of the grid.
- Pressing the Delete key was erasing the content of a Readonly textbox when the property label was selected.
- In TabKey mode, a property with a "None" feel could take the focus when pressing tab on the previous focusable property.
- In TabKey mode, if a property with a "None" feel was selected, pressing Tab was giving the focus to the next control in the form, not to the next focusable property.
- When the user was clicking on the dropdown arrow of a UITypeEditor and was continuing to move the mouse, the editor could not refresh itself until the mouse stopped moving.
- The PropertyEnumerator.Depth property could return an invalid result after using one of the Movexxxxx methods.
- CTRL + A does not beep anymore when typed while a property label (i.e. the internal grid) has the focus (the inplace control has not the focus yet).
- Changing a color (back, fore) on a PropertyValue from the PropertyChanged event handler will also change the corresponding color in the current inplace control.
- In your custom inplace control classes, instead of calling the PropertyValue.SetValue() method you must now call the PropertyValue.SetValueFromInPlaceCtrl() method.
- In class PropertyValueDisplayedAsAttribute, the DisplayedStrings property and the GetDisplayedStrings method are now virtual to ease derivation.
- The PropertyValue.Recreate() method now takes an argument: a boolean to indicate if the PropertyCreated event must be sent or not.
- The PropertyGrid can now host the new datetime inplace control (separate product called Smart FieldPackEditor.Net).
- When calling SetManuallyDisabled and the initial state is "disabled", the descendant properties were not correctly set as disabled.
- The +/- glyph color was not the correct one for a property with child properties when a dropdown form was open.
- When adding a second value to a property with the ValueAddedToPropertyAttribute while filling the grid with SelectedObject, the operation was failing if the PropertyDescriptor for the second value was supplied by a TypeConverter (instead of being a descriptor for a regular property).
- In TABkey + autofocus mode, if an hyperlink property was already selected, clicking on the hyperlink had no effect.
- In TABkey mode, if there was a unit inplace control below another unit control, changing the unit in the first one tried to commit the new value in the second one.
- There was a crash if a PropertyDescriptor was returning null for Category. SPG now loads and sets the localized "Misc" string for the empty category.
- There was a crash when typing in the textbox part and SPG tries to match the typed key with the first letter of one of the possible displayed values to switch to it.
- There was a crash when creating a managed property that publishes some child properties.
- When adding a root category, the check was not done to see if a vertical scrollbar had to be shown.
- There was a stack overflow when dealing with a managed property and the recreation of its children when its value changes.
- PropertyGrid.DrawingManager was not returning the correct drawing manager when you were using a custom manager derived from a built-in one.
- When using SelectedObjects, the multiple target instances were correctly set to the first level of properties but not to their descendants.
- In KeepFocus mode, it was impossible to leave an inplace control with a textbox (except by hitting ESC) if the textbox was empty and the property was targetting several instances. The empty value (null internally) was refused by the attached TypeConverter inside the new validation engine.
- The tooltips for the toolstrip are now localized (before, they were harcoded english strings).
- When switching from classic to XP theme rendering (and vice versa) the change was not taken into account in the drawing engine.
- In the mode (Enabled==false && DisabledMode==Simple) it was possible to see and trigger the button of a UITypeEditor, and therefore edit the underlying value, which should not be possible in a disabled mode.
- SelectedObjects has been improved so that child properties at level2 and deeper of one target instance are correctly analyzed for potential conflicts with the same properties in the other target instances.
- A very consuming GDI memory leak has been fixed.
- When setting a trackbar property to Readonly, the trackbar control was still visible and usable if it had been displayed previously.
- When a property using a checkbox inplace control was bound to several target instances with different values, there was a crash when showing the inplace control.
- When using a list inplace control, the container of the dropdown list (PropInPlaceContainer class) was never disposed and as such the window handle was always present in the windows hierarchy (as seen under ManagedSpy).
- If a call to TypeConverter.ConvertToString returns null, SPG transforms it into an empty string to avoid a crash due to a faulty TypeConverter.
- When using SelectedObject(s), the BrowsableAttribute filter was always implicitely used and it was not possible to use a custom filter (with the PropertyPreFilterOut event).
- The size and placement of the UITypeEditor are now calculated correctly (they were not under some circumstances). It does even better than the Microsoft PropertyGrid by always relying on the editor PreferredSize property.
- SelectedObject couldl crash when using the SortedProperty attribute on a property that has children.
- The first root category with a height multiplier greater than 1 could be truncated at the top of the grid after calling SelectedObject when it uses the SortedCategoryAttribute.
- The documentation was wrong in the section concerning the ValueAddedToProperty attribute.
- The TargetInstance property has been added to the class PropertyPreFilterOutEventArgs.
- Fixed a crash appearing when displaying empty value strings in bold or italic.
- A missing Refresh() call was missing in Property.HeightMultiplier, preventing from playing with the height multiplier of a property in realtime while resizing the grid.
- The icon at the left of property labels was painted vertically centered instead of being aligned with the label. This was a problem for properties with a height multiplier greater than 1.
- Value validation engine has been reworked. It is now possible to keep the focus on the faulty value.
- SPG is now compatible with Skybound VisualTips (www.skybound.ca) which is of great use with the new validation mode.
- If an exception is thrown by the client application while setting a value to a property, it is not "eaten" anymore and will be managed by the validation mechanism.
- MouseEnter, MouseHover and MouseLeave events from the InternalGrid are now forwarded to the parent PropertyGrid.
- The method PropertyEnumerator.IsDescendantOf(PropertyEnumerator) has been added.
- RealtimeChange property is now functional for Unit inplace controls.
- The Escape key now restores the old value for inplace controls whose RealtimeChange property had been set to true.
- PropertyGrid.UpdateInPlaceControlFromValue() has been added to update the content of the active inplace control when the value of the property has changed externally.
- PropertyGrid.SelectAndFocusProperty() has been added to select a property and force the focus on the inplace control of a property. A parameter enables also to select all the text if the inplace control contains a textbox.
- PropInPlaceUITypeEditor.ButtonText has been added so that it's possible to change the button text of modal UITypeEditors, like it was already the case for button feels.
- In the AppendProperty/InsertProperty methods, the code checking for the presence of BrowsableAttribute has been kept by inadvertence. It should have been erased since this is now taken care of in SelectedObject with the addition of the new PropertyPreFilterOutEvent event.
- All event handlers were passed arguments as EventArgs and it was necessary to cast it to the correct derived class.
- Fixed double click on the property value in the textbox part of a combobox (it would not cycle the value more than once on the inplace control that has RealtimeChange set to false). The same behavior occurs when typing the first letter of possible values.
- The margin at left/right of any text was not correct when setting a bold font to the grid.
- Setting the DrawingManager at runtime was not recalculating the size of the client area.
- Changing BorderStyle was showing some flicker.
- Calling DisplayMode was forcing the focus on the grid.
- It was impossible to revert from a DisableMode set to Full.
- When clicking in the text of a textbox corresponding to an already selected property, the text was incorrectly scrolled to the right if it was truncated by the right border of the grid.
- It was impossible to change the DisplayMode from Flat to FlatSorted and vice-versa without passing first by the Categorized mode.
- The margin used everywhere between texts and boundaries was static. It was creating display problems when showing two PropertyGrids with different font sizes.
- Italic text was possibly right-truncated by the overhang value (~ 2 pixels).
- When resizing the grid, the height of the comments area was not checked. It could end up with a grid filled only by the comments area.
- While scrolling down with the arrow key, there was an annoying remanence of the inplace control on the previously selected property when it was the last displayed at the bottom.
- Some Refresh() calls were missing when setting some colors on a PropertyValue.
- When PropertyGrid.ReadOnlyVisual was changed, the existing readonly properties were not changed (enabled/disabled) according to the new value.
- It was impossible to create a managed property with a certain type and to initialize it with a value from a derived type.
- It was impossible to specify an EditorAttribute in the parameters of Append(Managed)Property (broken since 2.0).
- GetRegisteredFeel now throws an exception if a feel can't be found.
- All the events have their name changed. The term "event" has been removed from their names.
- The ActualText property, when it exists, in inplace controls has been replaced by Text.
- The DisableModes enumeration does not contain EverythingGrayedOut anymore. It has been replaced by a DisableModeGrayedOut property which is an option for all the disable modes.
- All TabKey submodes have been moved to the TabKeyNavigationModes enumeration.
- In order to keep the same level of quality, the DateTime inplace control can not be used with the dropdown calendar anymore. It was too difficult to manage in all possible situations. Instead, you can rely on the usual DateTime UITypeEditor or use it in updown button mode.
- The library now supports .Net 1.1.
- SelectedObject(s) can now be called even if not in categorized display mode.
- An image can be drawn at the left of any property label (previously it was feasible only for categories).
- IInPlaceControl.TextBox has been added so that the textbox of any inplace control can be accessed.
- The event InPlaceCtrlCreatedEvent and the callback method OnInPlaceCtrlCreated have been added. This event happens before InPlaceCtrlCreatedVisible and enables the client application to customize the inplace control sooner (when the customizations recreate the handle of the control for instance). One example is to configure the inplace control with autocomplete feature (see sample).
- Typing a character in a textbox, which is readonly due to exclusive possible values, changes the value to the next possible string beginning by the typed letter. So far it was possible only in listboxes having no textbox.
- IInPlaceCtrl.CommitValue() added.
- PropInPlaceDateTime.RealtimeChange added so that you can control when CommitValue() is called (at each change or upon validation).
- OnPropertyChanged is fired for properties that are using a CollectionEditor. There is a bug in the Microsoft PropertyGrid that prevents knowing if a collection has actually changed after edition in the editor. The PropertyValueChanged event in the Microsoft PropertyGrid is not even fired (it is for arrays, not for most collections). In SPG, a way has be found to fire the event in such cases.
- PropertyGrid.OnPropertyPreFilterOut() has been added so that you can override the default mechanism that filters out properties that have the BrowsableAttribute(false) attached.
- The width of the columns is now set by calling PropertyGrid.LabelColumnWidthRatio with a percentage value.
- MouseClick (for .net2), MouseDoubleClick (for .net2) and Click events in the internal grid are now forwarded to the PropertyGrid.
- There was a crash when clicking on a non readonly datetime inplace control while coming from a readonly datetime inplace control, and vice versa.
- Clicking in another app while a dropdown list is opened will prevent the same listbox from being opened when focusing back the grid with the same property still selected.
- Calling Clear() while in non categorized mode was not clearing the properties collection correctly.
- When a PropertyDescriptor was changing its readonly state, the change was not reflected in the grid.
- Checkboxes were not drawn correctly when disabled in non XP theme.
- The width of the button in the UITypeEditor inplace control was not calculated correctly.
- The listbox for an enumeration attached to a TypeConverter of your own could be empty.
- The hit test in radio button and checkbox inplace controls was buggy. It was visible when adding more than 6 or 7 items in the control and was producing a shift when clicking (the next value after the one clicked was selected).
- In TAB mode, ending the editing of the last property could cause the inplace control to disappear even with the property still selected.
- OnPropertyChanged was not correctly triggered for checkboxes (set to RealtimeChange) with an underlying ArrayList.
- Found a workaround for the native focus bug in the DateTimePicker control. When the month calendar is closed, giving the focus back to the control without the mouse would put the focus selection mark nowhere. The user had to hit an arrow key.
- Fixed some issues with the DateTime inplace control, one of them being OnPropertyChanged triggered when changing only one field of the date/time or when clicking in the month calendar month and year buttons.
- A child property was automatically set readonly when its parent was also readonly even if NoLinkWithChildren was set on the parent's PropertyValue.
- Shift+Enter and Ctrl+Enter now works correctly with a multiline textbox to create a line break.
- A collection editor attached to a readonly property (no "set" accessor) was not shown to let the user edit the content of the collection (should have been fixed in 2.0).
- PropertyValidatorMinMax is not a generic class anymore. Instead, it takes arguments that interface IComparable.
- It is now mandatory to attach a validator to a property that uses a trackbar.
- PropertyValue.NoLinkWithChildren has now by default the value "true". It means that you must set it to false each time you create a grouped property whose parent and children have a logical link (like the WindowSize in the sample).
- PropertyGrid.LabelColumnFollowsResize has been removed. The underlying behaviour becomes the norm.
- PropertyGrid.OnPropertyFilterOut() is now called OnPropertyPostFilterOut().
- PropertyGrid.LabelColumnWidth.set does not exist anymore. Use LabelColumnWidthRatio instead.
- PropertyGrid.SelectedObjects has been implemented.
- PropertyGrid.SelectedObjectChangedEvent has been added.
- Navigation with TAB (+shift) key has been implemented. It offers various sub-modes of operation.
- The height of the gap between the grid and the comments area is not hardcoded anymore. This is now an overridable property (CommentsGapHeight) of the CustomDrawManager class.
- The DateTimeEditor (don't mix it up with the DateTime feel) can now handle nullable dates.
- PropertyGrid.HitTest() returns three new identifiers : Label, CommentArea and LeftColumn.
- The Return key on a (sub)category switches between expanded and collapsed states.
- A double-click on the label of a property now puts the focus in the textbox or scrolls through available values like in the MSPG (independently from any inplace control type). Contrarily to MSPG, shift + double-click also works in reverse order.
- A double-click on the value of a property now scrolls through available values like in the MSPG (independently from any inplace control type). Contrarily to MSPG, shift + double-click also works in reverse order.
- PropertyGrid.ExpandAllProperties() has been added to expand or collapse all properties in one shot.
- In the brightness/saturation map of the alphacolor picker dropdown control, arrow keys can be used to modifiy the saturation and/or brightness.
- PropertyDisableAttribute was usable only for child properties of the property that is decorated. It now works with the decorated property itself.
- PropertyHideAttribute was usable only for child properties of the property that is decorated. It now works with the decorated property itself.
- Up/Down/PgDown and PgUp keys are now handled on the textbox part of a trackbar feel to modify the trackbar value;
- PropertyLookAttribute can now take the parameters that will be passed to the Look constructor. Very handy when using SelectedObjects.
- PropertyHeightMultiplierAttribute class has been added (example use: to set the height of a multiline textbox in SelectedObject mode).
- ManuallyDisabledAttribute class has been added. It allows to call SetManuallyDisabled(propEnum, true) on the decorated property when SelectedObject is used.
- A test has been added to ensure that the type of the initial value passed to AppendManagedProperty matches the type passed in the same call. If it mismatches, an exception is thrown.
- CTRL + left/right arrows changes the width of the label and value columns by a step of 3 pixels.
- PropertyDateTimeLook has a constructor to accept Format, CustomFormat and ShowUpDown properties. Therefore these values can be passed when the look is assigned at design-time with an attribute.
- PropertyGrid.LabelColumnFollowsResize has been added to keep the ratio of column widths during a user resize.
- Child properties of a parent property whose TypeConverter does not supply PropertyDescriptors are now sorted by the PropertyGrid.PropertyComparer.
- The sample's form is now resizable.
- PropertyTypeDescriptorContext now contains a reference to the PropertyGrid.
- The Checkbox inplace control was not calling OnPropertyChanged properly.
- Closing the dropdown list of a Unit inplace control by clicking on the dropdown button was closing and reopening the list at the same time.
- In a Unit inplace control, there was a blink on the textbox (temporary SelectAll) if it contained the focus and the user was clicking on the dropdown arrow.
- The +/- glyph or a root or sub category was not vertically centered if using a HeightMultiplier greater than 1.
- An exception (MemberAccessException) is thrown when a property whose name is given in the call to AppendProperty or InsertProperty can't be found in the target instance type.
- It is now possible to assign a null value to managed properties (created with AppendManagedProperty).
- There was a crash when using a string data type with radio-buttons.
- Since 1.5, OnDisplayValuesNeeded was called only for dropdown lists and if PropertyValue.ResetDisplayedValues() was called. Now it will be called at property creation and then later if ResetDisplayedValues() is called.
- Some TypeConverter's conversion methods were not using PropertyValue.CultureInfo.
- When using several properties with FeelEditTrackbar, the textbox was not sized property when moving from one property to the other one.
- An anti-recursion mechanism has been added to PropertyGrid.EnableProperty so that calling EnableProperty from OnPropertyEnabled with the current Enabled state won't recurse.
- Applying the PasswordPropertyTextAttribute attribute to a property now automatically selects the correct password look and feel classes.
- A bug causing a null reference exception in ValueAddedToPropertyAttribute.Equals() has been fixed.
- Using [PropertyLook(null)] had no effect. This is used when one wants to clear the automatic assignment of a registered look for a given type.
- There was some issues with the PropertyEnumerators, preventing certain loops to work property. Also sometimes, a Clone() call was necessary.
- The PropertyMaskedEditLook class now displays the mask with the prompt character visible.
- The child properties of a collection that has been modified (by its editor) are recreated.
- The Delete key had no effect on a UITypeEditor when it was not focused (it normally should give the focus and delete the text).
- The tooltip trigger was not calculated correctly for UITypeEditors. The consequence was that the tooltip was not appearing if the text was slightly truncated.
- TypeConverter.CreateInstance was not called with the proper TypeDescriptorContext and propertyValues.
- NoWrap was missing in the PropertyPasswordLook. Long passwords were displayed on several lines.
- A property with a password look was passed bullets in its Set accessor when Escape was pressed.
- PropertyEnumerator.Equals() was not overloaded to compare values. It was comparing only references.
- Crash when a ComponentEditor was attached to a property that had no UITypeEditor.
- A collection editor attached to a readonly property (no "set" accessor) was not shown to let the user edit the content of the collection.
- UITypeEditor.PaintValue is now passed the ITypeDescriptorContext.
- Crash when using SelectedObject and one of the properties that publishes subproperties returns null for its value (this was the case when targetting the form in the sample and BackgroundImage has a null value).
- PropertyCultureInfoAttribute class has been removed from the project. It was of no need at design-time. Use PropertyValue.CultureInfo instead.
- Property.Look has been added as a shortcut. Use this instead of PropertyValue.Look.
- The feel instance has been transferred to the PropertyValue class, however Property.Feel has been kept has a shortcut.
- The PropertyTrackBarLook class name has been changed to PropertyProgressBarLook.
- PropertyGrid.SelectedBkgColor has been renamed to SelectedBackColor.
- PropertyGrid.SelectedNotFocusedBkgColor has been renamed to SelectedNotFocusedBackColor.
- PropertyValue.CurrentImageListIndex has been renamed to ImageIndex.
- ReadOnlyForeColor has now the default value GrayText.
- EllipsisMode has now the default value EllipsisOnValuesAndLabels.
- Microsoft UITypeEditor classes are now supported by the SPG framework.
- Dropdown boxes have now a resize box if needed.
- PropertyValue.ResetDisplayedValues(...) has been added to delete or change the values displayed for an enumerable type (previously it was possible to set them only at compile time with an attribute).
- PropertyGrid.OnDisplayedValuesNeeded is now called by the framework each time there is no displayed values defined.
- Added some DefaultValueAttributes to avoid unnecessary serialization by the IDE designer.
- Possibility to create a parent and children properties that have nothing in common. The parent acts like a category (with the look of a property) with a value part. Changing a child does not modify the parent and vice-versa. To use it, call PropertyValue.NoLinkWithChildren.
- The actual trackbar of the PropInPlaceTrackBar class is now accessible from the client application (to register to events for example). Get it by calling PropInPlaceTrackbar.TrackBar.
- PropertyChangedEventArgs has now a field SelectedIndex to know the entry selected by the user in a dropdown list and in a radiobuttons inplace control.
- Ability to control the size of the images displayed in the value part of a property by calling PropertyValue.ImageSize. It means that you can keep the original image size when you increase the height of the property. By default the image scales with the property height.
- The PromptChar can be changed for the MaskedTextbox inplace control.
- The PropertyGrid can be disabled with different options. You can disable everything, the selection of properties or the selection of just the values.
- There is no need to attach the DateTime feel and look to a DateTime property, they are now registered to be automatically assigned.
- There is now a distinction between DisabledForeColor and ReadonlyForeColor.
- PropertyValue.PropertyDescriptor is now accessible when applicable.
- The right and center mouse buttons now select the clicked property (without putting the focus on the inplace control).
- In flat and flatsorted mode, the shift of a property label was not calculated correctly for a depth greater than one.
- When clicking on the internal grid, the virtual methods OnMouse.... are called but the corresponding events were not triggered.
- When gaining the focus indirectly (not a mouse click in the grid but ALT-TAB for example) the selected property was not repainted as focused.
- When using SelectedObject and some PropertyDescriptors returning the same value for "Name", only the first PropertyDescriptor was used, giving several properties pointing to the same data.
- Unicode strings were not displayed correctly in the value column (and in the corresponding tooltip).
- When creating a property with AppendManagedProperty and a PropertyValueDisplayedAs attribute was set on the type itself, it was not taken into account.
- When setting a bold font on the Property class, the textbox of the value was X-shifted.
- The F4 key to open the dropdown list was not working anymore in a Unit inplace control if the textbox had the focus.
- When the TypeConverter can't convert from a string or GetStandardValuesExclusive() returns true, the textbox was not set as ReadOnly.
- It was not possible to attach a simple string as the Unit part of a PropInPlaceUnit. Only enumerations were handled. Now a string can be the unit and OnDisplayedValuesNeeded will be called to know all the possible units.
- It was not possible to set the Focus on the grid from outside (for example from the form to set the initial focus on the grid).
- The item height of a dropdown listbox is now calculated using the font height and the PropertyVerticalMargin field of the PropertyGrid.
- Property.CanBeDisabledManually.set has been replaced by PropertyGrid.SetManuallyDisabled to fix a bug related to setting a manually disabled checkbox on a property whose parent is disabled.
- The DateTime inplace control could not be readonly.
- The mouse hover effect under an XP theme was not right on the dropdown button, push button and updown buttons.
- When two different properties were showing radio buttons, the inplace control was not reinitialized correctly from one to the other and it was sometimes impossible to change the underlying values.
- Down and Up arrow keys were not working on the combo part of a Unit inplace control.
- When using an ImageList in a PropertyValue and the user changes the value by using the textbox (FeelEditList feel), the image index was not changed.
- Fixes on the password inplace control.
- PropertyGrid.HighlightedTextColor was not used by subcategories text and by +/- glyphs on properties and subcategories.
- The attribute ShowChildPropertiesAttribute was not detected on the type of a property added with AppendManagedProperty.
- Not really a bug, but a double click on the vertical line between labels and value as well as the double click on a category were handled on the mouse up, not the mouse down.
- With a grouped (managed) property, if one of the children was of type string, the space character following the separator character was included in the child value as a leading space.
- Added the notification OnInPlaceControlHidden.
- PropertyGrid.SelectedNotFocusedBkgColor has been added to change the background of a selected property when the grid is not focused.
- To let client applications develop their own drag and drop (among others), mouse down, mouse move and mouse up events in the internal grid are forwarded to the parent PropertyGrid.
- Calling PropertyGrid.SelectedObject = null; was crashing.
- Since version 1.3, clicking on the "sort alphabetically" button was crashing.
- The TypeDescriptorContext of a property was not always passed to GetProperties() and GetPropertiesSupported().
- Calling SelectProperty was showing the inplace control even if the grid had not the focus.
- When clicking on a property, OnInPlaceControlVisible could be called twice in certain circumstances.
- Hyperlinked properties were not visible under the Flat display modes.
- HighlightedTextColor was not taken into account.
- When changing the display mode (PropertyGrid,DisplayMode) the button in the toolbar was not correctly updated.
- When a dropdown listbox has no entry selected because no entry corresponds to the value in the textbox, clicking outside the listbox to close it was triggering a value change with an empty string.
- Hyperlink properties (those occupying the full row) were taken into account in the calculation done by PropertyGrid.AdjustLabelColumn().
- The ReadOnly state of a property value was not correctly read from PropertyDescriptor.IsReadOnly.
- Attributes now use AttributeUsage with AllowMultiple set to true when necessary. It allows not to pass big arrays to their constructor and to apply multiple instances of the same attribute instead.
- A PropertyValidator attribute can now be applied on the children of a property.
- A new notification has been added: OnPropertyFilterOut. It allows you to remove the property based on your criterias just after it has been created using SelectedObject.
- The management of enum fields is now done correctly when using Browsable and PropertyValueDisplayedAs attributes when the enumeration is defined in another language like C++.
- DescriptionAttribute was not handled when using SelectedObject.
- It was not possible to assign a Checkbox feel to boolean child properties of a parent property like a font (whose TypeConverter returns true for GetCreateInstanceSupported()).
- PropertyValueDisplayedAs attribute can now be applied on individual fields of an enumeration.
- There is no need to call PropInPlaceUpDown.UpdateByNotifications anymore to set custom increments on properties that use an updown control.
- Custom attributes have now overrides for Equals() and GetHasCode().
- The readonly state of a property value can now be changed on the fly with Property.Value.ReadOnly
- PropertyValueDislayedAsAttribute can now be used for a string type. Previously when showing a listbox with such a type it was mandatory to handle OnDisplayedValuesNeeded.
- Browsable(false) applied on individual enum fields are now taken into account and the fields won't be displayed. (experimental)
- PropertyValueIndirect.TypeConverter was not caching the TypeConverter correctly.
- There was a major flaw with how the validation was applied on a new edited value. The property was actually changed with the new value, then validated then reverted back to the old value if the validation failed. Now, the property is updated only if previously validated on a generated interim value.
- Crash when sorting the properties alphabetically and the first displayed property was already the first in alpha order.
- A checkbox for a boolean with an empty text was still displaying an (empty) focus rect. A check has been added to prevent that.
- The rectangle around the +/- glyph in front of categories in the LightColorDrawManager was not drawn correctly.
- Fixed the double-clic on a +/- glyph.
- The tooltip was sometimes appearing on a property showing its inplace control when the mouse was in the bottom pixel row.
- At 2 places in the code, I was modifying the global StringFormat.GenericDefault.
- The icon in a combobox property was not redrawn correctly if the user was opening the listbox, typing an arrow key and escape.
- Alt+down/up and F4 keys were not always handled correctly in combobox type properties.
- A listbox had no maximum height.
- Setting a property to invisible could have some side effects in some circumstances (regression bug).
- It is possible to create a property with multiple values while using SelectedObject by putting a ValueAddedToProperty attribute on the additional properties.
- PropertyLook.OnDraw() now contains a generic drawing code. No need to override it in simple derived looks.
- Contrarily to the MSGrid, when a property is selected, the Escape key does not enter in edit mode nor beep.
- The TypeDescriptorContext passed to a TypeConverter contains a reference to a Property.
- Each HyperLinked property can now send an event to different handlers.
- Customized cultures can be applied on a per property basis.
- Cultures are passed to TypeConvertes.
- PropertyValue.TargetInstance (get) has been added to retrieve the target of a property.
- Crash when attemting to assign a checkbox look and feel to a property that has been created through SelectedObject.
- Crash when requestiong the Name (not the DisplayName) of a category (a category is not linked to a .net property so it cannot get its name).
- A ReadOnly attribute passed to AppendProperty or such method was not taken into account.
- On a dual screen configuration, the color listbox could appear on the wrong screen.
- PropertyGrid.CommentsHeight now checks for too big values.
- When double-clicking on the value part of an unselected property, the double-click was not transmitted to the newly appeared inplace control.
- Some bugs were preventing the DateTime feel to be used normally to display dates and the month calendar.
- It was not possible to set a property Id with the PropertyId attribute to auto-discovered children of a parent property.
- LabelColumnWidth was not accepting a value if outside the client rectangle width when set from Form.InitializeComponent().
- When using AppendProperty or InsertProperty, the Browsable attribute was ignored, whether it is applied at design-time or at runtime.
- Crash when trying to find the dropdown content of a property whose parent has a PropertyDropDownContent attribute.
- When using SelectedObject, the TypeConverter of the target instance was not taken into account.
- A click on the arrow of an opened combobox was closing and then reopening the listbox instead of just closing it.
- The space key was triggering the popup of a combobox.