This example is obsolete.
In newer versions, use the built-in UserCellPadding property.

For older versions:
This example demonstrates how to create a custom GridView with the CellPadding property to specify paddings for its cells

The simplest way to change these colors is to modify the corresponding skin properties:

[C#]
varskin=CommonSkins.GetSkin(LookAndFeel);skin.Colors[CommonColors.HighlightSearch]=Color.Red;skin.Colors[CommonColors.HighlightSearchText]=Color.Blue;

[VB.NET]
Dim skin = CommonSkins.GetSkin(LookAndFeel)
skin.Colors(CommonColors.HighlightSearch) = Color.Red
skin.Colors(CommonColors.HighlightSearchText) = Color.Blue

If it's necessary to obtain these colors, use the following code:

[C#]
ColorbackColor=skin.Colors.GetColor(CommonColors.HighlightSearch);ColorforeColor=skin.Colors.GetColor(CommonColors.HighlightSearchText);AppearanceDefaulthighlightAppearance=LookAndFeelHelper.GetHighlightSearchAppearance(LookAndFeel,true);

[VB.NET]
Dim backColor As Color = skin.Colors.GetColor(CommonColors.HighlightSearch)
Dim foreColor As Color = skin.Colors.GetColor(CommonColors.HighlightSearchText)
Dim highlightAppearance As AppearanceDefault = LookAndFeelHelper.GetHighlightSearchAppearance(LookAndFeel, True)

Using this approach you can change colors of a highlighted text application wide. See the How to change one skin element in all available skins article for details.

Note, however, that we recommend that you create a custom skin using our Skin Editor tool. This approach is more stable since skin element names can be changed in future releases.

Alternatively, you can use custom painting to complete this task. This example illustrates how to customize foreground and background colors of a search string highlighted within located records in a grid using this approach. The main idea is to handle the CustomDrawCell event and use the ViewInfo.MatchedRanges property to paint the highlighted text.

Multiple total summaries are supported for a single column starting with version 11.1. To enable this feature, use the GridColumn.Summary property.

This example demonstrates how to display multiply summaries in the same column both in group and total footers.

Sometimes there is a requirement to extend existing business classes when you cannot modify their source code.

For instance, you have an assembly where some persistent classes are declared. You want to use it in your XAF application and add attributes, new members, etc..

To use types from external assemblies, add them to the application as described in the Ways to Add a Business Class - Add Classes From a Business Class Library or Module article.

To see how to extend business classes at runtime, refer to the eXpressApp Framework > Concepts > Business Model Design > Types Info Subsystem > Use Metadata to Customize Business Classes Dynamically article.

This example demonstrates how to:

- Add an attribute to an existing class
- Create a new simple persistent property
- Create new reference and collection properties linked by an association

Important notes

1. By design you cannot dynamically add or remove the OptimisticLocking and DeferredDeletion attributes.

2. Adding custom members for Domain Components (DC) should be done on the XafApplication.SettingUp event as described at How do I define a custom member for a domain component (DC) at runtime?.

3. In XAF versions prior to 15.1.4, you cannot dynamically establish an association between two persistent classes via the XafTypesInfo API. Use the XPDictionary API instead.

See also:

How to: Access Business Class Metadata

How to create business classes at runtime based on predefined configurations or allow user to define custom members via the application UI

As described in the Custom column/row values ( Show Field Values that are not present in the original data source ) ticket, PivotGridControl cannot display field values in row and column areas if these values are not represented in the underlying datasource. As a workaround you can add all required values to the original datasource or create a datasource wrapper that contains all required values on its level, and there is no need to modify original datasource.
This example illustrates how to create such a datasource wrapper. It is based on the How to create a data source wrapper that adds an empty item to the lookup list example.
To hide rows and columns with null field values, handle the CustomFieldValueCells event.

In the example, the CustomDates collection is filled with DateTime values based on the actual Start/End DateTime range and the specified interval (e.g., Month). This collection is passed to the DateDataSourceWrapper class instance along with the original data source collection (Table.DefaultView). The main idea of creating a custom wrapper class is to merge the CustomDates collection with the original data table without modifying the latter one. So, when PivotGridControl requests data using the common IList and ITypedList interface methods, wrapper returns data from the original collection or generates EmptyObjectPropertyDescriptor objects to return rows with null "Date" field values. For instance, check the DateDataSourceWrapper.this[int index] and DateDataSourceWrapper.GetItemProperties method implementations.

You can also check the following example that illustrates the ITypedList interface concept: How to: Implement the ITypedList Interface.

This example demonstrates how to represent an action via the BarCheckItem. For this purpose, a SimpleAction descendant (CheckableSimpleAction) is implemented, because it is required to save the checked state of the action. To represent a custom action in a UI, the BarCheckItemCheckableSimpleActionControl is used. To bind an abstract action to its UI representation, a custom CheckableSimpleActionBinding is created. The binding operation is performed by CustomActionControlController. 

Note that in most cases, it is not required to implement a custom action and action item. It is sufficient to customize the existing action item as described in the How to: Customize Controls Associated with an Action topic.

An example for ASP.NET is available here: How to create a custom action type with a custom control in Web

Scenario

This example shows how to keep the legacy database schema intact when creating an XAF application. Sometimes our customers want to connect their XAF applications to legacy databases, but they often have strong restrictions that disallow any changes in the legacy database schema, i.e. adding new tables, columns, etc. However, depending on the configuration, XAF may need to create additional tables. If the XafApplication.CheckCompatibilityType property is set to CheckCompatibilityType.ModuleInfo, the ModuleInfo table is used to track module versions. If you are using the Security System, additional tables are created to store users, roles, and permissions. XPO itself can add the XPObjectType table to correctly manage table hierarchies when one persistent object inherits another. Usually, legacy databases contain plain tables that can be mapped to one persistent object. So, the XPObjectType table is not necessary in such scenarios.

In this example, we customize the data storage mechanism to store the ModuleInfo and XPObjectType tables in a temporary database.

For this task we introduced a custom IDataStore implementation, which works as a proxy. This proxy receives all the requests from the application's Session objects to a data store, and redirects them to actual XPO data store objects based upon a table name that has been passed.

Steps to implement

1. In YourSolutionName.Module project create a custom IDataStore implementation as shown in the WinWebSolution.Module\XpoDataStoreProxy.xx file;

2. In YourSolutionName.Module project create a custom IXpoDataStoreProvider implementation as shown in the WinWebSolution.Module\XpoDataStoreProxyProvider.xx file;

3. In YourSolutionName.Module project locate the ModuleBase descendant and modify it as shown in the WinWebSolution.Module\Module.xx file;

4. Define connection strings under the <connectionStrings> element in the configuration files of your WinForms and ASP.NET executable projects as shown in the WinWebSolution.Win\App.config and WinWebSolution.Win\Web.config files.

IMPORTANT NOTES

1. The approach shown here is intended for plain database tables (no inheritance between your persistent objects). If the classes you added violate this requirement, the exception will occur as expected, because it's impossible to perform a query between two different databases by default.

2. One of the limitations is that an object stored in one database cannot refer to an object stored in another database via a persistent property. Besides the fact that a criteria operator based on such a reference property cannot be evaluated, referenced objects are automatically loaded by XPO without involving the IDataStore.SelectData method. So, these queries cannot be redirected. As a solution, you can implement a non-persistent reference property and use the SessionThatPointsToAnotherDatabase.GetObjectByKey method to load a referenced object manually.

3. As an alternative to the demonstrated proxy solution you can consider solutions based on database server features. Create a view mapped to a table in another database as a Synonym. Then map a regular persistent class to this view (see How to: Map a Database View to a Persistent Class).

See also:
How to implement XPO data models connected to different databases within a single application
How to: Use both Entity Framework and XPO in a Single Application

[C#]
privatestring[]tempDatabaseTables=newstring[]{"ModuleInfo","XPObjectType"};privateboolIsTempDatabaseTable(stringtableName){if(!string.IsNullOrEmpty(tableName)){foreach(stringcurrentTableNameintempDatabaseTables){if(tableName.EndsWith(currentTableName)){returntrue;}}}returnfalse;}

[C#]
e.ObjectSpaceProvider=newXPObjectSpaceProvider(provider);

[C#]
e.ObjectSpaceProvider=newSecuredObjectSpaceProvider(provider);

This sample illustrates how to change a cell template based on a condition using CellTemplateSelector.

To implement this approach, do the following:

1. Implement custom DataTemplates. Editors declared in these templates should follow our recommendations from this help topic: CellTemplate:

[XAML]
<DataTemplatex:Key="booleanEditor"><dxe:CheckEditName="PART_Editor"/></DataTemplate><DataTemplatex:Key="buttonEditor"><dxe:ButtonEditName="PART_Editor"/></DataTemplate><DataTemplatex:Key="comboboxEditor"><dxe:ComboBoxEditName="PART_Editor".../></DataTemplate><DataTemplatex:Key="dateEditor"><dxe:DateEditName="PART_Editor"/></DataTemplate><DataTemplatex:Key="textEditor"><dxe:TextEditName="PART_Editor"/></DataTemplate>

2. Create a custom DataTemplateSelector descendant. This descendant should return templates according to your scenario requirements.

Note: Each GridControl cell contains an object of the EditGridCellData data type in its DataContext. This object's RowData.Row property contains your data item. You can use this property if your logic should take property values from data items into account:

[C#]
publicclassEditorTemplateSelector:DataTemplateSelector{publicoverrideDataTemplateSelectTemplate(objectitem,DependencyObjectcontainer){GridCellDatadata=(GridCellData)item;vardataItem=data.RowData.RowasTestData;returnstring.IsNullOrEmpty(dataItem.Editor)?null:(DataTemplate)((FrameworkElement)container).FindResource(dataItem.Editor);}}

This example shows how to create a custom standalone Column Chooser and display it within the Expander control.

In this example, we implemented a custom CustomColumnChooserControl control that can be placed on a form. For example:

[XAML]
<Grid><Grid.ColumnDefinitions><ColumnDefinition/><ColumnDefinitionWidth="170"/></Grid.ColumnDefinitions><dxg:GridControlx:Name="grid"><dxg:GridControl.View><dxg:TableViewx:Name="tableView"/></dxg:GridControl.View></dxg:GridControl><local:CustomColumnChooserControlx:Name="columnChooser"Grid.Column="1"/></Grid>

To associate it with a grid, set the CustomColumnChooserControl's View property to the grid's View object and set the DataViewBase.ColumnChooserFactory property in the following manner:

columnChooser.View = view;
view.ColumnChooserFactory = New CustomColumnChooser(columnChooser);

Important note.

Starting with version 13.2, GridView provides a built-in checkbox column for multiple row selection. So, to enable this type of multiple row selection in newer versions, it is sufficient to enable the GridViewOptionsSelection.MultiSelect option and then set the GridView.OptionsSelection.MultiSelectMode property to the GridMultiSelectMode.CheckBoxRowSelect value. Take a look at the How to use an unbound check box column to select grid rows example for sample code.

Starting with version 18.1, in multiple row selection mode, you can sync row selected states with a Boolean field in the bound data source. The selection binding mode ensures that row selection persists whenever you filter or group grid data. Refer to the Multiple Row Selection via Built-In Check Column and Selection Binding help article for more information. 

If you still prefer the custom approach described below, please clarify why the built-in solution is not suitable for you. Just click here to submit a ticket to our Support Center.

For earlier versions:

This example demonstrates how to add a check column to allow web-style multiple row selection. End-users can select/deselect rows, group rows or select/deselect all rows by clicking the column header. Changing a check box value does not initiate row editing. 

All code related to selection resides in the GridCheckMarksSelection helper class. So, to implement this functionality in your application, you can simply add this class to your project and then create a new GridCheckMarksSelection instance.
Please note if you use the AppearanceEvenRow and AppearanceOddRow styles, by default they have a higher priority than the RowStyle event used for the selection in this example. To avoid drawing incorrect selected rows, enable the e.HighPriority option. 

The GridCheckMarksSelection class also provides different ~Select methods which allow selecting data and group rows in code. To obtain selected rows, you can use the SelectedCount property and GetSelectedRow method.

Starting with version 13.2, GridView provides a built-in checkbox column for multiple row selection. To enable this type of multiple row selection in newer versions, it is sufficient to enable the GridViewOptionsSelection.MultiSelect option and then set the GridView.OptionsSelection.MultiSelectMode property to the GridMultiSelectMode.CheckBoxRowSelect value. 

Starting with version 18.1, in multiple row selection mode, you can sync row selected states with a Boolean field in the bound data source. The selection binding mode ensures that row selection persists whenever you filter or group grid data. Refer to the Multiple Row Selection via Built-In Check Column and Selection Binding help article for more information.

If you still prefer the custom approach described below, please clarify why the built-in solution is not suitable for you. Just click here to submit a ticket to our Support Center.

If you are using an earlier version of DevExpress controls, refer to the Multiple selection using checkbox (web style) example which demonstrates a method to manually create a check column for row selection. 

Officially, GridControl doesn't support horizontal cell merging.  We recommend using Spreadsheet, which supports cell merging:

How to: Merge Cells or Split Merged Cells

If you still prefer the custom approach described below, please clarify why the built-in solution is not suitable for you. Just click here to submit a ticket to our Support Center.

If it's necessary for you to have this functionality in GridControl, you can use this example, which demonstrates how to merge cells located in the same row.
The main idea is to paint merged cell manually. You can find a helper class in this example, which can be easily connected to your existing GridView.

The TreeList control provides support for a TreeView visual style, in which the control mimics the appearance of the .NET standard TreeView control. Starting from version 17.2, the TreeView visual style can be enabled using the single setting - ViewStyle.

In versions prior to 17.2, you can emulate the TreeView visual style as follows

- Hide column headers (set OptionsView.ShowColumns to False).
- Hide the indicator panel (set OptionsView.ShowIndicator to False).
- Hide the horizontal and vertical lines between cells (set OptionsView.ShowHorzLines and OptionsView.ShowVertLines to False).

In version 14.1, we have added the GridView.OptionsView.ColumnHeaderAutoHeight property . 

If you still prefer the custom approach described below, please clarify why the built-in solution is not suitable for you. Just click here to submit a ticket to our Support Center.

For older versions: 

This example demonstrates how to introduce a capability to adjust the column header panel's height, based upon the column header contents.

THIS EXAMPLE IS OBSOLETE SINCE THE REQUIRED FUNCTIONALITY IS SUPPORTED OUT OF THE BOX. 

Starting with version 15.2, we implemented the XtraMessageBoxArgs.Showing event that is designed to customize the dialog form before it is shown. This allows you to disable/enable buttons, specify the form's start position etc.
Also, in version 18.1, we introduced the Auto Close feature for the XtraMessageBox dialog. Use the XtraMessageBoxArgs.AutoCloseOptions to customize it.

FOR EARLIER VERSIONS:

This example demonstrates how to create a MessageBox with an extended functionality. For this, create MyXtraMessageBox class descendant that is inherited from the XtraMessageBox class and uses the XtraMessageBoxArgs class - a MyXtraMessageArgs descendant which contains properties to customize the XtraMessageBox behavior. 

If the built-in functionality does not suit you, we will be happy to find the most appropriate solution for you if you describe your real-life scenario. Just click here to submit a ticket to our Support Center.

Starting with v17.2, GridControl supports a Drag-and-Drop mechanism based on native Drag-Drop events (see: Drag-and-Drop). Now, it's sufficient to enable TableView's AllowDragDrop property to enable this functionality.
For versions prior to v17.2, you need to use Drag-and-Drop Managers for this purpose. Use this example's implementation from previous branches when you use such managers.

In this example, we illustrated how to highlight a target data row during the Drag-and-Drop operation. We implemented an attached HotTrackedRowHandle dependency property that stores a target data row's RowHandle value. We set this value to a corresponding value at the TableView level in the DragRecordOver event handler.

When the Drag-and-Drop operation is completed, we disable such highlighting by setting this attached property to GridControl.InvalidRowHandle in the CompleteRecordDragDrop event handler.

The appearance of the target row is determined by a custom RowStyle defined in the TableView. This style sets a row's background to a certain color if the value from the attached HotTrackedRowHandle property equals to this row's RowHandle value.

Please refer to the implementation of the HotTrackedRowStyle style and HotTrackBehavior attached behavior to see this.

See also:
Behaviors
How to: Create a Custom Behavior

[XAML]
<Stylex:Key="HotTrackedRowStyle"TargetType="{x:Type dxg:RowControl}"><Style.Triggers>
        ...
    </Style.Triggers></Style>

This example shows how to access and remove rows by using a custom context menu for cells.

To implement such a context menu, add corresponding BarItems to TableView's RowCellMenuCustomizations collection:

[XAML]
<dxg:TableView.RowCellMenuCustomizations><dxb:BarButtonItemContent="Delete".../><dxb:BarButtonItemContent="Copy Cell Data".../></dxg:TableView.RowCellMenuCustomizations>

You can enable and disable such items based on property values in underlying data items. DataContexts in these items contain an object of the GridCellMenuInfo data type. This object's Row.Row property contains your data item instance. Therefore, you can bind to this data item's properties using the Row.Row.[Property_Name] path.

In this example, the Delete item is enabled only for rows whose CanBeDeleted property is True:

[XAML]
<dxb:BarButtonItemName="deleteRowItem"Content="Delete"IsEnabled="{Binding Row.Row.CanBeDeleted}"ItemClick="deleteRowItem_ItemClick"/>

This example demonstrates how a delete appointment action can be confirmed using a client-side scripting technique. Note that the delete appointment action can be initiated from two places: a context menu and appointment form of ASPxScheduler.

For versions 14.2+
Use the ClientScheduler.MenuItemClicked event to override context menu behavior. For example, to display a confirmation window when an end-user deletes an appointment, handle this event as shown below:

[ASPx]
<ClientSideEventsMenuItemClicked="OnMenuItemClicked"/>

[JavaScript]
function OnMenuItemClicked(s, e){if(e.itemName == "DeleteAppointment"){
                e.handled = !confirm('Are you sure that you want to delete this appointment?');}}

For versions prior to 16.2
To override context menu behavior, utilize the technique from the How to change default menu items and actions in the popup menu example. I.e., handle the ASPxScheduler.PopupMenuShowing Event and specify a custom client-side handler for the menu items via the e.Menu.ClientSideEvents.ItemClick parameter (see the code behind and markup of the "Default" webpage).

To override the "Delete" button behavior of the appointment form, you need to create a custom appointment form (see How to: Modify the Appointment Editing Form for Working with Custom Fields) and assign an appropriate client-side handler to the btnDelete.ClientSideEvents.Click property in the overridden DataBind() method of the form (see CustomAppointmentForm.ascx.cs code-behind file).

See Also:
How to implement a client-side confirmation on the user action modifying the appointment