This solution is created to illustrate the steps described in the Creating a registration form using ASPxEditors. Introduction tutorial series.

The solution consists of the following projects:

ASPxEditorsTutorial.Part1 - The resulting project for the Creating a registration form using ASPxEditors. Part 1 - Create the registration form layout article

ASPxEditorsTutorial.Part2 - The resulting project for the Creating a registration form using ASPxEditors. Part 2 - Customizing editors and adding built-in client-side validation article

ASPxEditorsTutorial.Part3 - The resulting project for the Creating a registration form using ASPxEditors. Part 3 - Adding a Cascading Combo Boxes feature article

ASPxEditorsTutorial.Part4 - The resulting project for the Creating a registration form using ASPxEditors. Part 4 - Saving data to database article

ASPxEditorsTutorial.Part5 - The resulting project for the Creating a registration form using ASPxEditors. Part 5 - Implementing the password verification mechanism article

ASPxEditorsTutorial.Part6 - The resulting project for the Creating a registration form using ASPxEditors. Part 6 - Checking the entered email address article

The OnSaving and OnDeleting method of the persistent objects can be overridden to log create/update/delete actions into a separate table. This example demonstrates the basic implementation of this feature.

Note: eXpressApp Framework have built-in module for Audit purposes. This example demonstrates how to use this module in non XAF application: How to use XAF Audit Trail module outside XAF.

UPDATED:

Starting with version v2014 vol 1 (v14.1), this functionality is available out of the box:
S173621: ASPxGridView - Add the built-in SelectAll CheckBox for Command Column

Simply set the GridViewCommandColumn.SelectAllCheckboxMode property to GridViewSelectAllCheckBoxMode.AllPages to activate it. Please refer to the ASP.NET: GridView Select All Rows Updated blog post and the Select All Rows demo for more information.

This sample illustrates how to add the "select all" check box dynamically within the HeaderCaptionTemplateContainer of the command column using the ITemplate interface.

This example demonstrates how to use the ASPxGridLookup to select multiple values from a dropdown grid containing lookup items. The ASPxGridLookup is bound with the custom DataItem defined within the "LookUpDataItem" type (contains row field).

The embedded ASPxGridView component is pre-customized as the ASPxListBox:

- The ASPxGridView's Header is hidden;

- The ASPxGridView's Pager is used for splitting DataItems within multiple pages to improve the client-side performance.

The embedded ASPxGridView's sever-side "CustomJSProperties" event is attached by handling the ASPxGridLookup's Init event. To get a reference to the embedded ASPxGridView, use the ASPxGridLookup.GridView property.

The embedded ASPxGridView's client-side "SelectionChanged" event is attached by handling the ASPxGridLookup's Init event, via the ASPxGridLookup.GridView.ClientSideEvents.SelectionChanged property.

UPDATED:

Starting with version v2014 vol 1 (v14.1), the "Select All" functionality is available out of the box:
S173621: ASPxGridView - Add the built-in SelectAll CheckBox for Command Column

Simply set the GridViewCommandColumn.SelectAllCheckboxMode property to GridViewSelectAllCheckBoxMode.AllPages to activate it. Please refer to the ASP.NET: GridView Select All Rows Updated blog post and the Select All Rows demo for more information.

OBSOLETE:

For the "Select All" functionality, instructions from the ASPxGridView - How to implement SelectRows and SelectAllRowsOnPage CheckBox features KB Article is used.

For the "partial selection" functionality, newly implemented ASPxCheckBox rendering (ASP.NET Check Box - New Render State For Multiple Controls (available now in v2011.1)) is used.

This sample illustrates a possibility to change themes on-the-fly. You can easily change all your pages' look and feel like in demos which come with our product. Please note that this demo's base class is inherited from a BasePage class declared in Utils.cs (or Utils.vb file).

See also
ASP.NET Themes In DLL: Easy Theme Deployment
How To Deploy DevExpress ASP.NET Themes
ASP.NET Themes and Skins
How to: Apply ASP.NET Themes

This example demonstrates how to create a detail grid with different sets of columns.
When DataControlDetailDescriptor is used to create a detail grid, all columns are synchronized. So, a detail grid with DataControlDetailDescriptor cannot contain different sets of columns. Therefore, we used ContentDetailDescriptor to create a detail grid with different sets of columns in this sample.

This example demonstrates how to serialize and deserialize custom properties with a custom type. If a custom property is null when the deserialization process is invoked, it's necessary to handle the DXSerializer.CreateContentPropertyValue event. In the CreateContentPropertyValue event handler, create a new instance of a custom type and assign it to the XtraCreateContentPropertyValueEventArgs.SomeCustomProperty property. 

This example implements the following scenarios when an end-user clicks on a custom item in the navigation control:

- a custom non-XAF form is opened as a result;

- a standard XAF View containing a custom user control is opened as a result.

Both custom forms and user controls display persistent data from the XAF application database. For that purpose, this example solution provides a set of reusable elements (custom ViewItem and Application Model extensions) organized in a way that you can once implement them in an XAF module and reuse to display custom user controls in various forms.

Take special note that if you do not need your custom controls to display data from the application database or do not require a complex and reusable solution for this task,
you can use (recommended)a much simpler and built-in XAF solution - ControlDetailItemplaced within a DashboardView. Refer to the Using a Control that is not Integrated by Default article for more details.

If this is not your case, proceed to the instructions below:

1. Define a base structure of the navigation control in your XAF application, as shown in the E911.Module\Model.DesignedDiffs.xafml file.

You can simply copy and paste the contents of the NavigationItems element into the corresponding file (pre-opened via the text editor) of your platform-agnostic module.

The same customizations can be achieved via the Model Editor visually.
Take special note that you can set the View parameter to any View from the list, e.g. AboutInfo_DetailView, BaseObject_ListView, etc.

This navigation structure will be further customized in the WinForms and ASP.NET executable projects later.

2. Intercept events of the navigation control to display a custom form when a custom navigation item is clicked.

To do this, implement a WindowController into your platform-agnostic module and handle events of the ShowNavigationItemController class as per the E911.Module\Controllers\ShowCustomFormWindowController.xx file. This controller will be abstract and be overridden in WinForms and ASP.NET modules.

3. Declare a custom ViewItem class that is supposed to host a custom user control in the standard XAF View. To do this, implement a custom ViewItem descendant and related types in the platform-agnostic module as shown in the E911.Module\Editors\CustomUserControlViewItem.xx file.

This ViewItem will also be abstract and platform-agnostic as it will not create platform-dependent controls, and will just provide a common customization code for both platforms. For instance, the OnControlCreated method will be overridden to bind the created control to data. To access persistent data from the database used by an XAF application, the ViewItem will implement the IComplexViewItem interface that consists of a single Setup method, receiving the IObjectSpace and XafApplication objects as parameters.

To unify our data binding code for both platforms, the IXpoSessionAwareControl interface and an auxiliary XpoSessionAwareControlInitializer class are introduced.

The interface provides a single UpdateDataSource method that is implemented by custom forms and user controls to bind them to data received by means of XPO.

You can use a similar mechanism and modify these auxiliary types to pass other custom data into your custom forms and controls.

4. Define a base structure of the standard XAF View with a custom ViewItem as shown in the E911.Module\Model.DesignedDiffs.xafml file.

You can simply copy and paste the contents of the Views element into the corresponding file (pre-opened via the text editor) of your platform-agnostic module.

5. Create custom forms and user controls in WinForms and ASP.NET executable projects analogous with what is shown in the example. The easiest way to do this is to copy the contents of the E911.Win\Controls and E911.Web\Controls folders and then include the necessary files into your solution. Take special note that these custom forms and controls implement the IXpoSessionAwareControl interface to automatically receive persistent data and other parameters when they are created.

6. Implement platform-dependent behavior to open and customize custom forms and controls. To do this, copy the following files into your WinForms and ASP.NET module projects:

WinForms:

E911.Module.Win\Controllers\WinShowCustomFormWindowController.xx - contains an WinForms version of the WindowController, which is inherited from the platform-agnostic

E911.Module.Win\Editors\WinCustomUserControlViewItem.xx - contains an WinForms version of the ViewItem, which is inherited from the platform-agnostic one;

E911.Module.Win\WinModuleEx.xx - contains a registration code for WinForms version of the ViewItem;

ASP.NET:

E911.Module.Web\Editors\WebCustomUserControlViewItem.xx - contains an ASP.NET version of the ViewItem, which is inherited from the platform-agnostic one;

E911.Module.Web\WebModuleEx.xx - contains a registration code for ASP.NET version of the ViewItem;

E911.Module.Web\Controllers\WebShowCustomFormWindowController.xx - contains an ASP.NET version of the WindowController, which is inherited from the platform-agnostic one;

These platform-dependent versions of the WindowController and ViewItem are required to implement the creation and display of custom forms and controls using the means specific for each platform. They are also designed to provide the capability to be able to set custom forms and control settings via the Model Editor. For that purpose, custom Application Model extensions are implemented for the Navigation Item and View Item model elements.

7. Set the custom forms and controls settings for each platform.

To do this, copy the contents of the E911.Win\Model.xafml and E911.Web\Model.xafml files into the Model.xafml file in the executable WinForms and ASP.NET projects:

WinForms:

ASP.NET:

IMPORTANT NOTES

1. It is also possible to mix the traditional and XAF development approaches (consult our Support Team if you are not sure how to integrate your standard non-XAF solution into XAF), because an XAF application is a regular .NET application built of reusable blocks like View, ViewItem, Property and List Editors, etc. that eventually create and customize platform-dependent controls exactly the same way you do this without XAF. So, using XAF does not mean something absolutely new and allows you to reuse your existing development skills and practices. Of course, it is possible to create your own reusable blocks if the standard ones do not meet your needs. For instance, the example of a custom View class designed to show a custom form can be found on CodeProject here.

2. This solution contains some generic code (e.g., base WindowController and ViewItem) that is mainly required because our XAF application is for both Windows and the Web. You may avoid this generic code and make a simpler implementation if you are developing for only one platform.

3. You can display custom forms not only when interacting with the navigation control, but from any other place. To do this, intercept the events of a required entity, e.g., an XAF Controller, Action or a View. Refer to the product documentation or consult with our Support Team in case of any difficulties.

4. By default controls layout and user customizations are preserved only for built-in XAF ListEditors, because they have special code for that. If you embed a custom user control into XAF, you need to preserve its settings yourself as well, exactly like you would do when implementing this task in the "old way" in a non-XAF application. Refer to the control's documentation to learn more on how to accomplish this task.

Feel free to contact the respective product team if you experience any difficulties customizing this control.

See also:
How to show custom forms and controls in XAF
How to create controls dynamically
How much of XAF's default UI is customizable.
How to Show a Window via an Action
How to: Display a List of Non-Persistent Objects
How to: Display a Non-Persistent Object's Detail View from the Navigation
ShowNavigationItemController.CustomShowNavigationItem Event
XafApplication.CustomProcessShortcut Event

To edit a dictionary with PropertyGridControl, you can create a DictionaryWrapper class that implements the ICustomTypeDescriptor interface. The DictionaryWrapper’s GetProperties method should return the PropertyDescriptionCollection of PropertyDescriptor objects. To create this collection, use a custom class that implements an abstract PropertyDescriptor class.

This example is actually only for versions 12.2 and lower. In 13.1, we introduced the NavigationFrame control, providing a similar functionality out of the box. See How To: Use NavigationButtons to Navigate in WPF WindowsUI Applications for more information.

With version v12.1.5, a new namespace is available in our DevExpress.Xpf.Core.Extensions library. This namespace is DevExpress.Xpf.Core.MvvmSample. Using this namespace it is possible to create the Metro Navigation style. Refer to the DevExpress.Xpf.Core.Extensions library in your project and add the DevExpress.Xpf.Core.MvvmSample namespace (dxmvvm="http://schemas.devexpress.com/winfx/2008/xaml/mvvmsample", for xaml) to the using section of necessary files.

The first major step here is to represent a custom UserControl in a format that can be used by our MvvmRoot component. The MvvmRoot component allows you to register custom views and provide metro navigation between them. MvvmRoot is a wrapper around the whole Metro Navigation system. This component needs to be added to the MainWindow, and custom views should be registered in MvvmRoot.

Here are steps required to convert custom UserControls to custom views applicable for MvvmRoot. The main idea is to separate the UserControl data from your UserControl representation:

1. Inherit your custom UserControl from the ModuleView class. The ModuleView class is a UserControl descendant that supports our special IView interface. The ModuleView descendant will be your data representation.

2. Create a Module class descendant. Get data for your custom view in this Module descendant. The Module class instance will serve as DataContext for your custom view. In your custom view xaml, bind to data properties you specify in the Module descendant.

3. Now you have two modules. Register them in our MvvmRoot component. In the MainWindow, the following line is responsible for registration:

[XAML]
<dxmvvm:ModuleDescriptionModuleType="{x:Type viewmodel:Main}"ViewType="{x:Type view:MainView}"/>

Using these three steps, you can convert any number of user controls to custom views.

It is necessary to create the main view (with TileLayoutControl as representation) in a manner similar to the one you use to create your custom views. The only difference is that the main module part should be inherited from the MainModule class, not Module. In the MainModule descendant, declare a command to navigate via custom views. These commands will be available in the MainView representation, and you can assign them to the Tile.Command property:

[XAML]
<dxlc:TileStyle="{StaticResource VerticalTile}"Header="User Management"Background="#FF00ABDC"Command="{Binding ShowFirstViewCommand}">...</dxlc:Tile>

[C#]
publicclassMain:MainModule{#regionCommandsprotectedoverridevoidInitializeCommands(){base.InitializeCommands();ShowMainCommand=newSimpleActionCommand(DoShowModule<MainData>);ShowFirstViewCommand=newSimpleActionCommand(DoShowModule<FirstData>);//....}publicICommandShowMainCommand{get;privateset;}publicICommandShowFirstViewCommand{get;privateset;}//...voidDoShowModule<T>(objectp)whereT:ModuleData,new(){ShowModule<T>(p);}#endregion}

The ViewPresenter class with DoubleAnimation is used to provide smooth replacement of one view with another one.

This example shows how to sort group summary items along with the column that the summary is aligned with.

To add this functionality, you can use the proposed helper class (GroupSummaryOptions) in your solution. Just set the attached property of the Grid to "True".

Note that currently, DXGrid doesn't support sorting by multiple summaries in a single column out of the box. To implement it manually, handle the CustomColumnSort event.

This example illustrates how to create a chart control with a scrollable legend. This may be required, for instance, when a chart displays too many series, or a legend occupies too much space.

This example demonstrates how to display data from a data source in dxDataGrid created using the AngularJS approach.

See also:
Configure Widget - Angular Approach

Update:
Starting with version 13.1, we implemented banded grid support out of the box. See the Using Bands to Create Multi-Row Layout article and the E4625 - How to: Create a Banded View example for more information. The solution below applies to versions prior to 13.1.

This example demonstrates how to create the banded view for the DXGrid with the attached behavior.

See Advanced Banded View Layout with attached behavior for more information.

We have included this solution in the DevExpress.Xpf.Grid.v11.2.Extensions library shipped with the 11.2 major version. Refer to the GridDemo.BandedView demo module to see this feature in action.

We have created an example demonstrating how to implement the Drag&Drop functionality for the CardView.

This functionality is encapsulated in the CardDragDropManager class. So, all you need to do is to attach this behavior to the GridControl.

This example shows how to update GridControl's data source right after a cell editor value has been changed. To implement this scenario, we created a custom helper class exposing the CommitHelper.CommitOnValueChanged attached property.

This example uses the same idea as the one demonstrated in the E1801 - How to post values to the DXGrid DataSource immediately after changing a cell value thread. If you don't want to use custom helpers, check the solution from the E1801 example instead.

[C#]
classCommitHelper{publicstaticreadonlyDependencyPropertyCommitOnValueChangedProperty=DependencyProperty.RegisterAttached("CommitOnValueChanged",typeof(bool),typeof(CommitHelper),newPropertyMetadata(CommitOnValueChangedPropertyChanged));publicstaticvoidSetCommitOnValueChanged(GridColumnBaseelement,boolvalue){element.SetValue(CommitOnValueChangedProperty,value);}publicstaticboolGetCommitOnValueChanged(GridColumnBaseelement){return(bool)element.GetValue(CommitOnValueChangedProperty);}privatestaticvoidCommitOnValueChangedPropertyChanged(DependencyObjectsource,DependencyPropertyChangedEventArgse){GridColumnBasecol=sourceasGridColumnBase;if(col.View==null)Dispatcher.CurrentDispatcher.BeginInvoke(newAction<GridColumnBase,bool>((column,subscribe)=>{ToggleCellValueChanging(column,subscribe);}),col,(bool)e.NewValue);elseToggleCellValueChanging(col,(bool)e.NewValue);}privatestaticvoidToggleCellValueChanging(GridColumnBasecol,boolsubscribe){if(!(col.ViewisDataViewBase))return;if(subscribe){if(col.ViewisTreeListView)(col.ViewasTreeListView).CellValueChanging+=TreeCellValueChanging;else(col.ViewasGridViewBase).CellValueChanging+=GridCellValueChanging;}else{if(col.ViewisTreeListView)(col.ViewasTreeListView).CellValueChanging-=TreeCellValueChanging;else(col.ViewasGridViewBase).CellValueChanging-=GridCellValueChanging;}}staticvoidTreeCellValueChanging(objectsender,TreeListCellValueChangedEventArgse){if((bool)e.Column.GetValue(CommitOnValueChangedProperty))(senderasDataViewBase).PostEditor();}staticvoidGridCellValueChanging(objectsender,CellValueChangedEventArgse){if((bool)e.Column.GetValue(CommitOnValueChangedProperty))(senderasDataViewBase).PostEditor();}}

To post values immediately, subscribe to the CellValueChanging event and call the View.PostEditor method.

If you don't want to handle events, check the E4155 - How to make GridControl immediately save changes in a cell after editing example demonstrating how to create a custom helper that does the entire job automatically.

By default, our extensions don't provide any specific method for this scenario. However, it's possible to accomplish this task by creating a special helper method which will take an original text as a parameter, and return a localized text defined in resources. If your data is stored in .xml, create several files for different cultures and dynamically assign them based on the current culture.
This example illustrates the both ideas. 

This example demonstrates how to use HtmlEditor to edit GridView row data