Actipro PropertyGrid for WPF

Property Editors

Provide a custom look and/or feel for any property displayed. This includes the value cell (right), as well as the name cell (left). Styles can be applied for simple customizations, or an entirely new data template can be used for full control.

The PropertyGrid showing various default property editors

Integrating the controls from our Editors for WPF product (sold separately) is a snap. This makes data entry much more intuitive for common data types.

The PropertyGrid with (right) and without (left) the Editors for WPF controls integrated

Category Editors

When simple inline property editors are not enough, category editors can be used. These allow more complex interfaces to be used inside the PropertyGrid for presenting/modifying specified properties. Examples of category editors can be seen in Microsoft Expression Blend.

The PropertyGrid with (right) and without (left) a category editor, used for modifying three color properties

Expandable Properties and Collections

Expandable properties, which are properties that expose one or more sub-properties, are fully supported. By default, only properties that use the ExpandableObjectConverter type converter are expandable, but other properties can be forced to be expandable as needed. Any properties whose type is a collection, such as IList<T>, IList, IDictionary<TKey, TValue>, etc, can also be expanded.

The PropertyGrid with (right) and without (left) properties forced to be expandable

Collection Editing

In addition to being expandable, there is built-in support for inline editing of collection properties. This includes adding and removing items, all of which can be easily customized, with the click of a button.

The PropertyGrid showing the inline editing of collection properties

Data Validation

Full support for the WPF validation system, which is used to validate user input, is included. Error templates, which provide a visual indication of invalid input, can be customized as needed. When total control is required, event handlers can be used to customize the data validation and error handling.

A custom error template used inside a property editor

Events

Several bubbling routed events and included, which notify you when:

• A property's value is changing
• A property's value has changed
• An item is being added to a collection
• An item has been added to a collection
• An item is being removed from a collection
• An item has been removed from a collection

These events are in addition to events that tell you when a property/category is being expanded or collapsed.

Summary Area

Information about the selected item can be presented in a fully customizable and resizable summary area, which shows the display name and description by default. Includes support for smooth animated transitions when the content changes.

The summary area with a custom button

Theming, Layout, and Localization

Built-in themes are included for the three Office themes and all Windows system themes. While this encompasses a lot of built-in themes, you can also generate a completely custom tinted theme with a single line of code. For advanced developers who want even more customization possibilities, we've made all our controls so that they can be styled and templated and all primitive elements that are used in our built-in control templates are public.

Includes supports right-to-left layouts and all text in the user interface may be localized to other languages.

Properties

Actipro PropertyGrid allows you to easily add or remove items, as well as apply custom sorting and/or filtering.

SelectedObjects and Items

There are several ways to populate the PropertyGrid. Properties can be statically defined in XAML, or in code, just like the native WPF controls. Additionally, the PropertyGrid can automatically display the properties of any .Net object(s). Best of all, you can use statically defined properties along side any dynamically generated ones.

Most of the configuration and options used with the Windows Forms PropertyGrid control are also supported by our PropertyGrid. This includes support for the type description architecture built into .NET, such as ICustomTypeDescriptor.

The PropertyGrid can also display the common properties of multiple objects. Any changes made by the end-user to a "merged" property is applied to all associated objects.

Factories

Factories are used to generate categories and properties from the selected object(s) and custom properties. There are two built-in factories which can be simply dropped in. Custom factories can be used to provide limitless possibilities, such as providing a collection or XML document editor. In addition, the built-in factories can be used as a basis for a custom factory to add or remove items from the default implementations.

The first built-in factory leverages TypeDescriptor, which ties into the .NET type description architecture, to examine an object's properties. This mimics how the Windows Forms PropertyGrid control works. The other built-in factory uses reflection to offer a simpler approach.

Categorization

Properties can be automatically categorized based on a specified category name. Additionally, a custom factory can be used to organize the properties and/or categories so that it suits your needs.

Nested categories, or categories inside other categories, can also be specified using a path syntax to the desired category. This feature is even supported when using CategoryAttribute to specify the category.

The PropertyGrid showing several properties in with (right) and without (left) nested categories

Sorting

The categories and properties can be easily sorted using SortDescriptions or any custom logic. Distinct sorting can be applied to individual categories or properties, or they can simply inherit the default behavior.

The PropertyGrid showing how custom sort logic can be used

An included sample shows how custom SortOrderAttribute and SortCategoryOrderAttribute classes can be used to define the sort order in the object itself. The code from this sample can be used free of charge in your applications, and does not require you to reference our PropertyGrid assembly from non-UI related assemblies.

Filtering

Properties and categories can be filtered using custom logic, which fully supports WPF bindings. This can be used to allow end-users to filter down the list of visible items to find a specific item.

The PropertyGrid showing how filtering can be used by end-users

An included sample shows how properties can be dynamically shown or hidden based on the value of another property, which allows you to only show properties that are relevant. As with all samples, you are free to use this code in your applications free of charge.

A custom factory can be used to filter items that should never be displayed, which can improve performance. Finally, the PropertyGrid has several configuration options to filter inherited properties, attached dependency properties, and more.

Virtualization

Full support for WPF's UI virtualization is included. This can drastically reduce load times and memory usage, since only the UI elements that are currently visible are created, measured and arranged. If there are thousands of items to be presented, then only a small subset of items will need to be processed and rendered.