For width of vertical scroll-bar define:

<s:CalendarView.Resources>
   <sys:Double x:Key="{x:Static SystemParameters.HorizontalScrollBarButtonWidthKey}">32</sys:Double>
</s:CalendarView.Resources>

For height of horizontal scroll-bar define:

<s:CalendarView.Resources>
   <sys:Double x:Key="{x:Static SystemParameters.VerticalScrollBarButtonHeightKey}">32</sys:Double>
</s:CalendarView.Resources>

The s: namespace refers to: xmlns:s=”clr-namespace:DevComponents.WpfSchedule;assembly=DevComponents.WpfSchedule”
The sys: namespace refers to: xmlns:sys=”clr-namespace:System;assembly=mscorlib”

Related posts:

1. WPF Schedule Quick Start Guide
2. How to customize WPF Office 2007 Color Schemes
3. How To Start Using Wpf-Ribbon Control

C#:

Backstage backstage = new Backstage();
ButtonDropDown btn = new ButtonDropDown();
btn.Header = "Save";
btn.ImageSource = "images/Save.png";
backstage.Items.Add(btn);
 
btn = new ButtonDropDown();
btn.Header = "Save As";
backstage.Items.Add(btn);
 
BackstageTab tab = new BackstageTab();
tab.Header = "New";
tab.PanelBackground = eBackstagePanelBackgroundImage.Green;
backstage.Items.Add(tab);
 
DockPanel panel = new DockPanel();
Label label = new Label();
label.Content = "Label Content";
panel.Children.Add(label);
tab.Content = panel; // Set tab content
 
AppMenu.BackstageTab = backstage;

VB:

Backstage backstage = new Backstage();
ButtonDropDown btn = new ButtonDropDown();
btn.Header = "Save";
btn.ImageSource = "images/Save.png";
backstage.Items.Add(btn);
 
btn = new ButtonDropDown();
btn.Header = "Save As";
backstage.Items.Add(btn);
 
BackstageTab tab = new BackstageTab();
tab.Header = "New";
tab.PanelBackground = eBackstagePanelBackgroundImage.Green;
backstage.Items.Add(tab);
 
DockPanel panel = new DockPanel();
Label label = new Label();
label.Content = "Label Content";
panel.Children.Add(label);
tab.Content = panel; // Set tab content
 
AppMenu.BackstageTab = backstage;

AppMenu in this case represents an instance of ApplicationMenu which has been assigned to the Ribbon.

Related posts:

1. How to build Office 2010 style Backstage application menu with DotNetBar for WPF
2. How to Create WPF Navigation Pane Items Using Code
3. How to Access and Change WPF-Ribbon Window Title Text Alignment

When you set DisplayMembers property the control automatically generates the column and sets default size for them. If you want to customize columns you have two options:

1. Handle advTree.DataColumnCreated event which is fired for each ColumnHeader control internally creates. Using event arguments you can get access to the ColumnHeader created and modify it to suit your needs.

2. Clear DisplayMembers property (must be set to an empty string or null/nothing) and create your columns manually in designer or using code. In designer simply use right-click->Edit Columns command. In code create new instances of ColumnHeader object, add it to advTree.Columns collection, set its properties to set it up the way you want it, and make sure to set columnHeader.DataFieldName property with the name of the field that holds data that will be loaded into the column. Note, that this must be done before DataSource is set.

Related posts:

1. How to use ItemPanel Data-Binding Features – WinForms
2. ComboTree Quick Start Guide
3. Data-binding on popup and DataSource

RadialMenu control provides two different types of menus:

1. MenuType = eRadialMenuType.Segment. This menu type allows showing of sub-menu items and menu item text. Following image shows this type of radial menu:

2. MenuType = eRadialMenuType.Circular. This menu type does not allow either sub-menu items or menu item text. It only shows Symbol or Image set on menu item. Following image shows circular menu type:

When menu is collapsed, not open, its circular button is visible on the form which when clicked opens the menu. This is what is seen when RadialMenu control is added to the form:

RadialMenu control accepts only RadialMenuItem object type to define its menu structure. These items are added to RadialMenu.Items collection.

RadialMenu control key properties

• BackButtonSymbol – specifies the symbol that is displayed in center of radial menu when sub-menu is shown. This button when clicked cycles back to parent menu.
• BackButtonSymbolSize – specifies the size of the back button symbol.
• CenterButtonDiameter – specifies the radial menu center button diameter in pixels.
• CloseMenuOnAppDeactivate – specifies whether radial menu if its open closes when application deactivates. Its not recommended to change default setting for this property since menu will be left open and you will have to close it manually from code.
• Colors – returns the color table that allows customization of all colors used by the radial menu control. Please see our RadialMenu sample project which is included with your DotNetBar install which shows how to use this property to customize RadialMenu colors.
• Diameter – specifies open radial menu diameter.
• Image – specifies image displayed on circular button which opens radial menu. Note that setting Symbol overrides the Image setting.
• IsOpen – gets or sets whether radial menu is open. You can use this property to open radial menu from code.
• Items – returns the collection which holds instances of RadialMenuItem objects which define the content of radial menu.
• MaxItemPieAngle – specifies the maximum pie angle an menu item can occupy, essentially maximum radial size of menu item.
• MaxItemRadialAngle – specifies maximum radial angle single item in menu can consume. By default this property is set to zero which indicates that radial menu is equally divided between visible menu items and constrained by MaxItemPieAngle property setting.
• MenuLocation – specifies custom menu location in screen-coordinates. For an example of how to use this property see RadialMenu sample project which is included with your DotNetBar install.
• MenuType – specifies the radial menu type.
• SubMenuEdgeItemSpacing – specifies spacing between the outer edge of the radial menu item and sub menu ring.
• SubMenuEdgeWidth – specifies width of the sub-menu ring that is drawn around the radial menu items and which shows whether an item has sub-menu and allows switch to sub-menu
• Symbol – specifies Symbol shown on circular button which opens the radial menu. When Symbol is set it overrides Image setting.
• SymbolSize – specifies the symbol size shown on circular button which opens radial menu.

RadialMenu control key events

• BeforeMenuOpen – occurs before radial menu is open and it allows you to cancel opening of the menu by setting Cancel=true on event arguments.
• ItemClick – occurs when any of the radial menu items is clicked. Can be used as single point click event handler for menu items although we recommend using Commands instead.
• MenuClosed – occurs after radial menu is closed.
• MenuOpened – occurs after radial menu is open.

RadialMenuItem key properties

• Checked – specifies whether radial menu item is checked. Applies only to MenuType=Segment.
• CircularBackColor – specifies background color for circular menu item. Applies only to MenuType=Circular.
• CircularBorderColor – specifies border color for circular menu item. Applies only to MenuType=Circular.
• CircularForeColor – specifies foreground color of the symbol displayed on circular menu item. Applies only to MenuType=Circular.
• CircularMenuDiameter – specifies diameter of the circular menu item. Applies only to MenuType=Circular.
• Command – specifies the command which is executed when menu item is clicked.
• Image – specifies image displayed on menu item. Note that if Symbol property is set, it will override image setting.
• IsMouseOver – returns whether mouse is over the menu item.
• SubItems – returns collection which represents sub-menu items. You add new instances of RadialMenuItem object to this collection to create sub-menus. Note that sub-menus are visible only for MenuType=Segment.
• Symbol – specifies symbol displayed on menu item. Note that setting Symbol will override image setting.
• SymbolSize – specifies symbol size.
• Text – specifies the text displayed on menu item. Note that you can use line break characters \r\n to break text into multiple lines. Applies only to MenuType=Segment.
• TextOffset – specifies optional text offset from its original layout position. Sometimes its necessary to adjust text location for best appearance. This is property to use.
• TextVisible – specifies whether menu item shows text if set. Applies only to MenuType=Segment.
• TracksMouse – specifies whether menu item changes its appearance to indicates when mouse is over.

How to create RadialMenu using code

For working demonstration please see our RadialMenu sample project included with your DotNetBar install.

C#:

RadialMenu menu = new RadialMenu();
menu.Location = new Point(32,32);
menu.Symbol = "\uf040";
menu.Diameter = 220; // Make menu diameter larger
// Handle some events
menu.ItemClick += new EventHandler(RadialMenuItemClick);
menu.MenuOpened += new EventHandler(RadialMenuOpened);
menu.MenuClosed += new EventHandler(RadialMenuClosed);
 
RadialMenuItem item = new RadialMenuItem();
item.Text = "Item 1";
item.Symbol = "\uf011";
menu.Items.Add(item);
 
item = new RadialMenuItem();
item.Text = "Item 2";
item.Symbol = "\uf00e";
menu.Items.Add(item);
 
item = new RadialMenuItem();
item.Text = "Item 3";
item.Symbol = "\uf010";
menu.Items.Add(item); 
 
// Create spacer item
item = new RadialMenuItem();
menu.Items.Add(item);
 
item = new RadialMenuItem();
item.Text = "Item 4";
item.Symbol = "\uf011";
menu.Items.Add(item); 
// Add sub items to last menu item
RadialMenuItem childItem = new RadialMenuItem();
childItem.Text = "Sub menu 1";
childItem.Symbol = "\uf012";
item.SubItems.Add(childItem); // Add sub menu to its parent
 
childItem = new RadialMenuItem();
childItem.Text = "Sub\r\nmenu 2";
childItem.Symbol = "\uf013";
item.SubItems.Add(childItem);
 
this.Controls.Add(menu); // Adds menu to the form

VB:

Dim menu As New DevComponents.DotNetBar.RadialMenu()
menu.Location = New Point(32, 32)
menu.Symbol = ChrW(&HF040).ToString()
menu.Diameter = 220 ' Make menu diameter larger
' Handle some events
AddHandler menu.ItemClick, AddressOf RadialMenuItemClick
AddHandler menu.MenuOpened, AddressOf RadialMenuOpened
AddHandler menu.MenuClosed, AddressOf RadialMenuClosed
 
Dim item As New RadialMenuItem()
item.Text = "Item 1"
item.Symbol = ChrW(&HF011).ToString()
menu.Items.Add(item)
 
item = New RadialMenuItem()
item.Text = "Item 2"
item.Symbol = ChrW(&HF00E).ToString()
menu.Items.Add(item)
 
item = New RadialMenuItem()
item.Text = "Item 3"
item.Symbol = ChrW(&HF010).ToString()
menu.Items.Add(item)
 
' Create spacer item
item = New RadialMenuItem()
menu.Items.Add(item)
 
item = New RadialMenuItem()
item.Text = "Item 4"
item.Symbol = ChrW(&HF011).ToString()
menu.Items.Add(item)
' Add sub items to last menu item
Dim childItem As New RadialMenuItem()
childItem.Text = "Sub menu 1"
childItem.Symbol = ChrW(&HF012).ToString()
item.SubItems.Add(childItem) ' Add sub menu to its parent

childItem = New RadialMenuItem()
childItem.Text = "Sub" & vbCrLf & "menu 2"
childItem.Symbol = ChrW(&HF013).ToString()
item.SubItems.Add(childItem)
 
Me.Controls.Add(menu) ' Add menu to the form

Related posts:

1. How to find CrumBarItem in CrumbBar control by name
2. How to change the ButtonItem.Symbol property using code
3. How to use ItemPanel Data-Binding Features – WinForms

C#:

// Following code enumerates through all nodes and prints out node text to console
foreach (Node node in AllNodes(advTree1.Nodes))
{
    Console.WriteLine(node.Text);
}
 
// This is what makes flat access to tree nodes easy
private static IEnumerable AllNodes(NodeCollection nodes)
{
    for (int i = 0; i<nodes.Count; i++)
    {
        Node node = nodes[i];
        yield return node;
        if (node.Nodes.Count > 0)
        {
            foreach (Node item in AllNodes(node.Nodes))
            {
                yield return item;
            }
        }
    }
}

VB:

' Following code enumerates through all nodes and prints out node text to console
For Each node As Node In AllNodes(advTree1.Nodes)
	Console.WriteLine(node.Text)
Next node
 
' This is what makes flat access to tree nodes easy
Private Shared Iterator Function AllNodes(ByVal nodes As NodeCollection) As IEnumerable
	For i As Integer = 0 To nodes.Count - 1
		Dim node As Node = nodes(i)
		Yield node
		If node.Nodes.Count > 0 Then
			For Each item As Node In AllNodes(node.Nodes)
				Yield item
			Next item
		End If
	Next i
End Function

Related posts:

1. AdvTree Drag & Drop Events And Options
2. How to accept external drag & drop on AdvTree control
3. How to find CrumBarItem in CrumbBar control by name

From code however, you need to use symbol unicode. That code would look like this:

C#:

button.Symbol = "\uf060";

VB:

button.Symbol = ChrW(&Hf060)

Here is the table with available symbols and corresponding unicode values:

Related posts:

1. How to Create Menu Using Code
2. How to Create Toolbars Using Code
3. Code generation for property failed

Ribbon Control does not manage the height automatically since it does not have knowledge about the full ribbon height. There might be items that you dynamically show, merged items from MDI Child forms etc. so it is developers responsibility to manage the height of the Ribbon.

The automatic scaling provided by Windows Forms is linear per control scaling. Since there are multiple RibbonBar controls on each Ribbon panel they will not scale the same due to the different content they have and Windows Forms framework does not know how to scale complex controls. For example the Image Size is fixed while the font size changes. That creates uneven non-linear sizing which is what you might see if you do not manage the height of the control.

RibbonControl has two sizing modes:

1. RibbonControl.AutoSize=false which means that you are in control of the height of the control. How do you manage the height is up to you. We recommend that you take a RibbonBar that you know that is tallest and determines the total height. Then use its RibbonBar.GetAutoSizeHeight() method to calculate the total height of the control. To that you can add RibbonControl.RibbonStrip.Height and also you might need to add couple of pixels to account for the borders, padding etc. This method should work very well if you use Form. AutoScaleMode = AutoScaleMode.Font
2. RibbonControl.AutoSize=true which means we are managing the height of the control based on the content that it has, which also means that height might change when you switch from tab to tab due to different size of the RibbonBar controls on each tab. Most people do not prefer this mode since they want to control the height of the control and control height changes based on what is selected. Office 2007 Ribbon Design Guidelines also state that ribbon should be fixed in height so this property should not really be used if compliance with guidelines is needed.

Related posts:

1. How To Perform Custom Ribbon Merging
2. Tips when working with Ribbon control from code
3. How to loop through all ribbon tabs, ribbon bar and items on WinForms Ribbon control

When you run the app (or open the form in VS.NET), that code creates and configures controls just as you did in the designer. So every single change you make and control you add ends up in InitializeComponent() method. This means that doing things at design-time and run-time is essentially the same. Note that you should not modify this method manually since it might confuse the VS.NET designer. However you should use it to learn how to do things from code and how to setup controls and components correctly.

In C# access to this method is always visible through form constructor. Simply position the cursor in InitializeComponent method call and press F12 in VS.NET and Form .designer file will open to show the implementation of the InitializeComponent method.

In VB.NET the Visual Studio hides the access to InitializeComponent method. Actual method implementation is in Form.designer.vb file for that form. File is accessible via Solution Explorer once you have clicked on the Show All Files toolbar button which you can find on top of the Solution Explorer window. Following video shows how to do this:

So if you want to find out how to create controls or setup things from code you can easily discover how to do that by doing what you want to do from code in VS.NET designer, say adding controls to the form and changing their properties, then you go to InitializeComponent() method and look through code that is generated and which shows how to create everything you see on the form. The easiest is to start with new form and simply add the controls to it and change their properties then go to InitializeComponent method to see how its done from code.

Related posts:

1. How to Create Menu Using Code
2. How to Create/Remove Tabs Using Code
3. How to Create Toolbars Using Code

For example to set width of the property name column to 100 pixels you can use following code:

advPropertyGrid1.SetPropertyColumnWidth(0, 100)

Related posts:

1. How to add custom panels to AdvPropertyGrid
2. How to create custom columns when binding data to AdvTree
3. How to create virtual properties with AdvPropertyGrid for WinForms

The minimum requirement for adding an AdvGrid to your application is a data source for the rows which implements IEnumerable. Simply bind your data source to the grid’s ItemsSource property. Each object in the enumeration becomes the DataContext for a row in the grid. The object’s properties are the source for the content of the row’s cells. The mapping between the object’s properties and the grid’s columns can be made automatically or you can define the mapping yourself if you require more control that what is provided by default.

Beyond setting up a data source, some of the more common settings to explore are:

• Set property VirtualizationMode = Recycling to enable both row and cell virtualization.
• Set IsByRowEditingEnabled = true to put the grid into by-row editing mode.
• Set CanUserAddRow = true to cause a “placeholder” row to be added to the bottom of the grid which the user can use to add a new row.
• Provide a DataTemplate as value for RowDetailsTemplate to create a details section for your rows.
• Use property RowDetailsShowMode to specify  when row details are made visible.
• Set AutoGenerateColumns = true to have columns automatically generated. Handle the routed event AutoGeneratingColumns to customize a column when it is being automatically generated.
• Set ScrollMode = ByItem to enable scroll-by-item.
• Use SelectionMode to specify whether Single, Multiple or Extented selection mode is active.
• Use SelectionUnit to specify whether cells, rows or cells and rows via the row headers are selectable by user.
• ColumnHeaderClickBehavior specifies what happens when the user cicks on a column header.
• Set AllowColumnReorder = true to allow the user to re-order the columns using drag and drop.
• Set IsContextMenuEnabled = true to enable a built-in context menu that allows the user to (optionally) sort, group, pin and hide/show individual columns.
• RowHeaderWidth specifies the width of the row headers.
• Filter the items that are displayed with a Predicate<object> set as value for the grid’s Filter property.
• Display your items in groups based on column values by setting the GroupByLevel of the appropriate column definition.
• Set ShowColumnGroupingPanel = true to display a panel into which the user can drag column headers to cause the grid to group the items by that column’s data.
• Set CanUserDeleteItem to allow the user to delete rows using the delete key.
• And many more…

A good place to start exploring AdvGrid, other than this document, is the AdvGridSample application which is included in the DotNetBar installation. Here is a screen shot:

AdvGrid, AdvGridRow and AdvGridCell

AdvGridRow is the native container type for items placed into the grid. New containers are obtained from the grid’s GetContainerFromItemOverride method. It is possible to override this method and supply your own row control type, but it must derive from AdvGridRow. Similiarly, AdvGridCell is the native container for cell data. When a new cell is required, it is obtained via the parent row’s CreateCell method. This too can be overridden to provide your own cell control.

Both AdvGridRow and AdvGridCell have Connect and Disconnect methods. The first is called by the system to prepare the row or cell for the data item that it is being used to display. The latter is called when the row is being virtualized and is used to release the control from the data object and make it available to connect to another. Inheritors of either AdvGridRow or AdvGridCell may need to override these methods if they define new dependency properties of their own, for example, or require some other custom connection logic.

AdvGrid is designed to look and act as much like ItemsControl as possible, but it does not have an ItemContainerGenerator. Instead, it has an ItemContainerManager (specifically, AdvGridItemContainerManager) the purpose of which is to manage row creation and the placement of the rows into the visual tree, and virtualization.

Following are lists of the common events, properties and methods available on AdvGrid, AdvGridRow and AdvGridCell controls.

AdvGrid Interface

AdvGrid Events:

AutoGeneratingColumn – A routed event raised when a new column is being auto generated. The new column can be customized in a handler for this event.

DeletingSelectedItems – A routed event raised before selected items are deleted as a result of user action. Handle this event to prevent the deletion.

SortByColumnRequested – A routed event raised when the user clicks a column header to sort (ColumnHeaderClickBehavior is SortByColumn.) Handle this event to stop default sorting and provide custom sorting.

SelectionChanged – A routed event raised when the selection changes.

ItemsChanged – A routed event raised when the content of the Items collection changes.

AdvGrid Methods

BeginEdit – Puts the currently active cell in the currently active row into edit mode.

BringIntoView – There are four overrides of BringIntoView which can be used to bring into view a specific row, a specific item, a specific index, and finally one for bringing into view a specific column.

ClearSelection – Clears current selection.

CancelEdit – Clears all pending changes and takes the current row and/or cell out of edit mode. See section on editing for more information.

ClearGroupByColumn – Clears grouping by the specified column.

CommitEdit – Pending changes are committed to underlying data source. See section on editing for more information.

ContainerFromIndex – Get the row at the specified index, with option to create the row if it doesn’t exist (applies when virtualization is enabled.)

ContainerFromItem – Returns the row given an item with optional parameter to specify whether or not to create the row if it does not exist.

DeleteSelected – Deletes the current selection. Before deleting items, the event DeletingSelectedItems is raised and if handled the delete does not happen.

IndexFromContainer – Get the index of the node within the flattened hierarchy of the tree.

IndexFromItem – Get the index of the item within the flattened hierarchy of the tree.

IsItemSelected – Use to determine if a particular item is part of the current selection.

GetActiveRow – Gets the row control which is container for the current ActiveItem.

GroupByColumn – Groups items based on values in the specified column.

MoveDown – Selects and makes active the row below the currently active row.

MoveLeft – Moves one cell to the left of the current cell.

MoveRight – Moves one cell to the right of the current cell.

MoveUp – Selects and makes active the row immeditely above the currently active row.

PinItem – Pins the row containing the specified item to either the top or bottom of the viewport.

Remove – Removes (deletes) the specified item from the Items collection. This is the same as calling Items.Remove().

SelectAll – If columns are being displayed, then all columns are selected.

SortByColumn – Causes child nodes to be sorted by the values of a specific column, in a specified direction.

AdvTree properties:

CLR Properties

AllSelected – Will return true if all columns are selected.

Items – Gets a reference to the underlying ItemsCollection. This is a read-only property.

ItemContainerManager – Gets a reference to the object responsible for container (row) creation and virtualization. This is the counterpart to ItemsControl’s ItemContainerGenerator.

LogicalExtent – This is the number of rows in the grid.

FirstVisibleNodeIndex – Gets the index of the first visible node (index is flattened, i.e. inclusive of all nodes regardless of hierarchy level.)

LastVisibleNodeIndex – Gets the index of the last visible node in the tree.

ScrollViewer – Gets a reference to the grid’s ScrollViewer, if there is one.

SelectedColumns – An enumeration of the ColumnDefinitions which are currently selected. Column selection is enabled by setting ColumnHeaderClickBehavior to SelectColumn.

SupressCellVirtualization – When VirtualizationMode is Recycling both nodes and cells are subject to virtualization. Set this property to prevent the virtualization of cells.

Dependency Properties

ActiveItem – This is the data item of the row which currently has keyboard focus. Read-only.

AllowColumnReorder – Specifies whether the user can reorder the columns using drag and drop.

AlternationCount – Performs same function as ItemsControl.AlternationCount. Setting to a value greater than 1 will result in the grid’s rows’ AlternationIndex values alternate between 0 and AlternationCount – 1. This value can be used in a Style trigger to modify properties of the nodes based on their alternation index. An example of this is provided in the sample AdvGridSample.

AutoGenerateColumns – Specifies whether column definitions should be automatically generated from available data when they are not provided.

CanUserAddRow – When true, a placeholder row is added to bottom of the grid. If the user edits a cell in the placeholder row, a new row is created.

CanUserDeleteItem – When true, the user can delete rows by hitting the delete key. Default is false.

ColumnAlternationCount – Alternation count for columns. Works the same as alternation count for rows.

ColumnDefinitions – Defines columns for the Grid. More on columns is provided below.

ColumnHeaderClickBehavior – Determines what happens when a column header is clicked. Possible values are SortByColumn: The rows are sorted by the column’s value. SelectColumn: The column is selected. Custom: No action is taken by the grid. Handle ColumnHeader.Clicked routed event to perform custom action. The column header is highlighted on mouse over and press.) And Nothing: Nothing is done and ColumnHeader.Clicked is not raised.

ColumnHeaderClickMode – Determines whether the click event of a column header is raised on mouse down or mouse up.

ErrorNotification – Applies only when IsByRowEditingEnabled = true. Specifies whether the user is notified of row level errors by a message box, by an Adorner (defined by Validation.ErrorTemplate) or not at all.

ErrorNotificationDialogBoxStyle – This Style is applied to the DialogWindow (DevComponents.WPF.Controls) which is opened to display row level error message.

Filter – A Predicate<object> which is applied to the grid’s Items collection.

FirstRowNumber – Specifies the starting index for the rows, and which are displayed by the row headers.

HighlightSelectedCellColumnHeader – Determines whether the column headers of selected cells are highlighted.

HighlightSelectedCellRowHeader – Determines whether row headers are highlighted cells are selected.

HorizontalGridLineBrush – Brush for horizontal grid lines when ShowHorizontalGridLines is set.

HorizontalGridLineHeight- Height of the horizontal grid line when ShowHorizontalGridLines is set.

HotTrack – When true, the cell with mouse over is highlighted.

IsByRowEditingEnabled – When true, by-row editing is enabled. See section on editing for more. The default value is false.

IsContextMenuEnabled – Determines whether the column header’s built-in context menu should be enabled.

IsDragDropEnabled – When set, the grid is set up to be both source and target of drag/drop. Is the same as setting both DragDrop.IsDropTarget and DragDrop.IsDragSource to true.

IsGrouping – A read-only property which is set to indicate that the items are being grouped.

IsSelectionFocusAware – When true, the selection box which highlights a selected item is grayed when the Grid does not contain the input focus.

ItemsSource – An IEnumerable which serves as source for the items which populate the Items collection. This property is equivalent to ItemsControl.ItemsSource.

ItemContainerStyle – Style for the item containers. Note that containers for AdvGrid are always instances of AdvGridRow.

ItemContainerStyleSelector – StyleSelector for selecting the Style for the container for a particular item.

LockRowHeaderWidth – Specifies whether the user is enabled to resize the width of the row headers. Default is true.

LockRowHeigths – Specifies whether the user is enabled to change row heights. By default will be false unless either virtualization or scroll by item are enabled, in which case LockRowHeight is set to true. The default behavior is overriden when LockRowHeight is explicitly set.

RowKeepsKeyboardFocusOnError – Applies when IsByRowEditingEnabled = true. If there is an error when attempting to commit changes, the user is prevented from navigating away from the row.

RowDetailsShowMode – Determines whether row details are displayed when a toggle button is checked, when the row is selected, always or none (manual.)

RowDetailsTemplate – A DataTemplate which if set both shows how to render the details section and causes the rows to have a details section.

RowHeaderWidth – Specifies the width of the row headers. Default value is NaN, which results in auto-sizing.

ScrollMode – Determines whether scroll-by-item is enabled and, if so, how the last item is positioned. Possible values are Normal, ByItem and ByItemBottomFlush. Default is Normal.

SelectedCell – When SelectionMode is Single and CellSelect is True, this property will identify the currently selected cell. When multiple selection is enabled, SelectedCell will be set to the first cell selected of the collection of selected cells.

SelectedCells – When SelectionMode is Multiple or Extended and CellSelect is True, this property will return an ObservableCollection containing the currently selected cells.

SelectedItem – Will identify the currently selected item when SelectionMode is Single. When multiple selection is enabled, SelectedItem will be set to the first item selected of the collection of selected items.

SelectedItems – When SelectionMode is Extended or Muliple, will return an ObservableCollection containing references to the currently selected items.

SelectionMode – Possible values are Single, Multiple and Extended. More on selection modes is provided below.

SelectionUnit – Determines whether cells, rows or both are selectable by user. This is an enumeration of type AdvGridSelectionUnit with possible values None, Cell, Row and CellOrRowHeader.

ShowColumnGroupingPanel – If true, a panel is shown into which the user can drag column headers for columns to group by.

ShowColumnHeader – Determines whether the column headers are shown.

ShowHorizontalGridLines – Determines whether horizontal grid lines are shown.

ShowRowDetailsRootLine – Applies when RowDetailsTemplate is set.

ShowRowHeaders – Determines whether the row headers are shown.

ShowVerticalGridLines – Determines whether the vertical grid lines are shown.

VerticalGridLineBrush – The Brush used for vertical grid lines.

VirtualizingMode – Sets the virtualization mode for the tree. Possible values are None and Recycling. Default value is None. More about virtualization is provided below.

VisualStyle – 5 built-in visual styles are included with AdvGrid the default, an emulation of Windows Explorer, and the three color schemes of Office 2010: Blue, Silver and Black. Setting this property is the same as setting a value for the VisualStyleManager.VisualStyle attached property on the grid. Note: to ensure consistent visual style through the entire application, set VisualStyleManager.VisualStyle on an element at the top of the visual tree.)

AdvGridRow Interface

AdvGridRow Events

BeforeSelected – A bubbling routed event raised before the value of IsSelected changes from false to true. Setting the event argument’s Handled property to true will cancel the selection.

Connecting – Routed event raised when the row is being connected to its data item and fitted into the visual tree. This event occurs as part of the virtualization/realization process.

Disconnecting – Routed event raised when a row is in the process of formally disconnecting itself from its data item. Will not be raised if virtualization is not enabled.

InitializingNewItemPlaceholder – Routed event raised when the item for the new item placeholder is being created. Will not be raised unless the grid’s CanUserAddItem property is true. Handle this event to set default values for the placeholder item, or to create a new item to serve as placeholder.

IsCellSelectedWithinChanged – Bubbling routed event raised when th value of IsCellSelectedWithin changes.

IsDetailsSectionOpenChanged – Routed event raised when the value of IsDetailsSectionOpen changes.

IsDirtyChanged – Routed event raised when the value of  IsDirty changes.

PinChanged – Routed event raised when the value of Pin changes.

Selected – A bubbling routed event raised when the value of IsSelected changes from false to true.

Unselected – Routed event raised when the value of IsSelected changes to false.

AdvGridRow Methods

BeginEdit – Puts the current cell into edit mode. If IsByRowEditingEnabled = true, then the row is also placed into edit mode.

CancelEdit – Rolls back any pending changes and takes the row and current cell out of edit mode.

CommitEdit – Commits pending changes to underlying data source and optionally takes the row and/or active cell out of edit mode. See section on Editing for more.

GetCell – Use to get an AdvTreeCell contained by the node that corresponds to a specific ColumnDefinition.

GetChildNodes – Use to obtain an enumeration of all of the node’s child nodes. Optionally include all the descendants of the child nodes as well. Option to include nodes which are unrealized.

NavigateLeft – Moves focus to and selects the cell immediately to the left of the currently active cell.

NavigateRight – Moves focus to and selects the cell immediately to right of currently active cell.

NavigateDown – Moves focus to and selects the row below.

NavigateUp – Moves focus to row above.

SortByColumn – Causes the node to sort children by a specified column, in a specified direction.

AdvGridRow Properties

CLR Properties

CellDefinitions – This is the ColumnDefinitionCollection which defines the columns which present the node’s data (not the node’s children.) By default, a node inherites this value from its parent node. If the parent node has a value for ColumnDefinitions, this becomes the child’s CellDefinitions.

Cells – Gets an enumeration of the AdvTreeCells which are children of the node. If HasCells is false, this property will return an empty enumerable.

HasCells – Gets whether this node has cells defined.

HeaderControl – Provides access to the control which renders the row’s Header.

IsEditing – Returns true if the node is currently in edit mode.

IsCellEditingWithin – Returns true if a Cell contained by the node is currently in edit mode.

IsConnected – Returns true if the node is currently connected – that is, it is in a valid state for rendering.

Items – An ItemsCollection which contains and manages the child items of the node.

ParentGrid – Gets the parent AdvGrid.

ValidationErrors – If ByRowEditingIsEnabled = true, this ReadOnlyObservableCollection will contain any validation errors that currently exist for the row.

Dependency Properties

AlternationIndex – This is a readonly property which is set by the framework when a parent’s AlternationCount is greater than 1. This property can be used in Style trigger to modify appearance of the node.

DetailsTemplate – A data template which defines how to display the details. If set, the row will have a details section, otherwise the row will not have a details section. By default, this value is inherited from the parent grid’s RowDetailsTemplate property.

DetailsToggleButtonStyle – Style for the toggle button which is

ErrorNotification – Applies only when IsByRowEditingEnabled = true. Specifies whether the user is notified of row level errors by a message box, by an Adorner (defined by Validation.ErrorTemplate) or not at all. By default this value is inherited from the parent grid’s property of the same name.

HasError – A readonly property which is set when there are validation errors associated with the row.

HeaderBackground – The Brush used to paint the background of the row’s header.

Header – The content displayed by the row’s header.

HeaderPadding – Padding for the header.

HeaderTemplate – A DataTemplate which shows how to render Header.

HorizontalGridLineBrush – Get or set the Brush used for the horizontal grid line. By default, this property is inherited from the parent grid.

HorizontalGridLineHeight – Determines the height of the horizontal grid line. By default, this property is inherited from the parent grid.

IsByRowEditingEnabled – Determines whether the the row is in by-row editing mode. By default, this value is inherited from the parent grid’s property of the same name.

IsCellSelectedWithin – Will be true if one of more cells within the row are selected. Readonly.

IsDetailsSectionOpen – Determines whether the details section is open. Ignored if there is no value for DetailsTemplate.

IsDirty – If by-row editing is enabled, this property is set when the user edits a cell and remains set until either the changes have been committed or the edit is cancelled (for example, the user hits the escape key.) See section on editing for more information.

IsEditing – This read-only property is set when the row goes into edit mode. Will never be set unless IsByRowEditingEnabled = true.

IsSelected – Gets or sets whether or not the row is selected. If IsSelectable is false, this property is ignored.

IsSelectable – Determines whether the row can be selected. The default value is true.

KeepKeyboardFocusWhenHasError – If by-row editing is enabled, setting this property make it so the user is prevented from leaving the current row if HasErrors = true. By default, this value is inherited from the parent grid’s RowKeepsKeyboardFocusWhenHasError property.

LockHeight – Determines whether the user can change the row’s height. By default, this value is inherited from the parent grid’s LockRowHeight property.

Pin – Determines whether the row is pinned to the top or bottom of the viewport, or not pinned at all (the default is not pinned.)

ShowHorizontalGridLines – Determines whether the horizontal grid lines are visible.

ValidationRules – Gets or sets a collection of ValidationRule objects used for row-level validation. Ignored if IsByRowEditingEnabled does not equal true. For more information, see section on editing below.

AdvGridCell Interface

AdvGridCell Events

BeforeSelected – A bubbling routed event raised before the value of IsSelected changes from false to true. Setting the event argument’s Handled property to true will cancel the selection.

EditBeginning – A bubbling routed event raised before the cell enters edit mode. Setting the event argument’s Handled property to true will cancel the edit.

EditCommitted – A bubbling routed event raised when changes are committed to the underlying data source.

IsDirtyChanged – A routed event raised when the value of IsDirty changes.

IsEditingChanged – A routed event raised when the value of IsEditing changes.

Selected – A bubbling routed event raised when the value of IsSelected changes from false to true.

Unselected – A bubbling routed event raised when the value of IsSelected changes from true to false.

AdvGridCell Methods

BeginEdit – Manually puts the cell into edit mode.

CancelEdit – Clears pending changes to the cell’s content and takes the cell out of edit mode.

CommitEdit – Commits pending changes with option to exit edit mode. If by-row editing mode is enabled, then the changes are only committed to row level. It is up to the parent row to perform the final commitment of changes to the underlying data source.

AdvGridCell Properties

CLR Properties

IndexInRow – Gets the zero based index of this cell within the row or node.

IsConnected – Gets whether this cell is fully connected to its data source and column definition, and is ready to be displayed in the UI.

IsEditing – Returns true if the cell is currently in edit mode.

Dependency Properties

BeginEditTriggerMode – provides a means for defining what conditions are required for the cell to enter Edit mode. (Only applies when IsEditable is true.) More on node and cell editing is provided below.

CellDefinition – Provides access to the ColumnDefinition instance which defines the cell. This is a read only dependency property.

EditorStyle – Specifies a style which is applied to the embedded EditingContentControl which both displays and edits the cell’s content. Note that the editing control’s style can also be specified in the column definition via property CellEditorStyle. In either case, a value is not required. More on editing below.

EditTemplate – Optionally specifies a ControlTemplate to be applied to the ContentEditingControl which both displays and edits the cells content. More below.

IsDirty – When true, it means the user has made changes to the cell content which have not been committed to the underlying data source.

IsEditable – When true, the cell’s content can be edited in place. See more about editing below.

IsEditing – Set when the cell enters edit mode.

IsHighlighted – Get or set whether the cell should be highlighted. Normally, this value is set when the mouse is over the cell.

IsSelectable – Determines whether the cell can be selected. The default value is true.

IsSelected – Gets or Sets whether the cell is currently selected. If IsSelectable is false, this property is ignored.

Columns

The grid’s columns are defined by a collection of ColumnDefinition objects. The collection is set and/or accessed through the grid’s ColumnDefinitions property. ColumnDefinitions is a dependency property so it can participate in data binding. Also, both ColumnDefinitions and ColumnDefinition are derived from System.Windows.FrameworkContentElement which allows them to inherit the drid’s data context and use bindings which refer to named elements in the visual tree.

The column definitions can be automatically generated from the data object set as the value of ItemsSource. If the object is an instance of System.Data.DataView then the columns are generated from the Columns in its Table. If the object is an enumeration of objects, then the columns are generated using the first object in the list. The public properties of this object are discovered using reflection. By default, a column is created for each public property. The column header will be the property’s Name, unless the propert definition is decorated with a DisplayName attribute (System.ComponentModel.DisplayNameAttribute.) To prevent a column from being created for a public property, decorate it with a DisplayName attribute and set the value to null.

By default columns will be auto generated if the column definitions are not otherwise provided for at the time the grid loads. To disable auto generation of columns, set property AutoGenerateColumns = false.

While auto column generation can be convienent if you are satisfied with the defaults, far more control is available if you define the columns explicitly. Columns can be defined in Xaml or code. Here is an example in Xaml (taken from the AdvGridSample application):

<dc:ColumnDefinitionCollection x:Key="CustomersGridColumnDefinitions" Padding="10" HorizontalContentAlignment="Center">
    <dc:ColumnDefinition Header="Name" BindingMemberPath="Name" CellIsEditable="True" AutoSizeToFitContent="True" CellHorizontalContentAlignment="Left" />
    <dc:ColumnDefinition Header="Age" BindingMemberPath="Age" CellIsEditable="True" AutoSizePadding="25">
        <dc:ColumnDefinition.EditorSettings>
            <dc:NumericEditorSettings IsButtonHighlightedOnMouseOver="True" MinValue="0" MaxValue="120" IsInCellEditingEnabled="False" EnforceMinMax="True" />
        </dc:ColumnDefinition.EditorSettings>
    </dc:ColumnDefinition>
    <dc:ColumnDefinition Header="Gender" BindingMemberPath="Gender" CellIsEditable="True" AutoSizePadding="20">
        <dc:ColumnDefinition.EditorSettings>
            <dc:EnumEditorSettings IsButtonHighlightedOnMouseOver="True" IsInCellEditingEnabled="True" />
        </dc:ColumnDefinition.EditorSettings>
    </dc:ColumnDefinition>
    <dc:ColumnDefinition Header="Income" BindingMemberPath="Income" CellIsEditable="True" AutoSizePadding="20">
        <dc:ColumnDefinition.EditorSettings>
            <dc:NumericEditorSettings IsButtonHighlightedOnMouseOver="True" MinValue="0" StringFormat="C" />
        </dc:ColumnDefinition.EditorSettings>
    </dc:ColumnDefinition>
    <dc:ColumnDefinition Header="Is Married" BindingMemberPath="IsMarried" CellIsEditable="True" />
    <dc:ColumnDefinition Header="Can Contact" BindingMemberPath="CanContact" CellIsEditable="True">
        <dc:ColumnDefinition.EditorSettings>
            <dc:BooleanEditorSettings Type="DropDown" DisplayNameFalse="Never" DisplayNameTrue="Any Time" IsButtonHighlightedOnMouseOver="False" IsInCellEditingEnabled="False" />
        </dc:ColumnDefinition.EditorSettings>
    </dc:ColumnDefinition>
    <dc:ColumnDefinition Header="Best Time" BindingMemberPath="BestTime" CellIsEditable="True" StringFormat="T" AutoSizePadding="20">
        <dc:ColumnDefinition.EditorSettings>
            <dc:TimeOfDayEditorSettings />
        </dc:ColumnDefinition.EditorSettings>
    </dc:ColumnDefinition>
    <dc:ColumnDefinition Header="Credit Card" BindingMemberPath="CreditCard" CellIsEditable="True" BeginEditTriggerMode="ClickSelected">
        <dc:ColumnDefinition.EditorSettings>
            <dc:DataFormEditorSettings PropertyType="{x:Type local:CreditCard}" DialogWindowTitle="Credit Card Properties" DisplayMemberPath="Issuer">
                <dc:DataFormEditorSettings.FieldDescriptors>
                    <dc:DataFormFieldDescriptor DisplayName="Name:" PropertyName="NameOnCard" />
                    <dc:DataFormFieldDescriptor DisplayName="Card Issuer:" PropertyName="Issuer">
                        <dc:DataFormFieldDescriptor.EditorSettings>
                            <dc:EnumEditorSettings />
                        </dc:DataFormFieldDescriptor.EditorSettings>
                    </dc:DataFormFieldDescriptor>
                    <dc:DataFormFieldDescriptor DisplayName="Expiration Date:" PropertyName="ExpirationDate">
                        <dc:DataFormFieldDescriptor.EditorSettings>
                            <dc:EditorSettings StringFormat="MMM, yyyy" Mask="LLL, 0000" />
                        </dc:DataFormFieldDescriptor.EditorSettings>
                    </dc:DataFormFieldDescriptor>
                    <dc:DataFormFieldDescriptor DisplayName="Number:" PropertyName="CardNumber">
                        <dc:DataFormFieldDescriptor.EditorSettings>
                            <dc:EditorSettings Mask="0000-0000-0000-0000"/>
                        </dc:DataFormFieldDescriptor.EditorSettings>
                    </dc:DataFormFieldDescriptor>
                </dc:DataFormEditorSettings.FieldDescriptors>
            </dc:DataFormEditorSettings>
        </dc:ColumnDefinition.EditorSettings>
    </dc:ColumnDefinition>
</dc:ColumnDefinitionCollection>

ColumnDefinitionCollection

Following is a list of the properties of ColumnDefinitionCollection. Note that several properties of ColumnDefinitionCollection have been mapped to AdvGrid for convienence. All of these properties are dependency properties and hence can be data bound.

• AllowColumnReorder –
• AllowColumnResize –
• AlternationCount –
• BorderBrush –
• BorderThickness –
• CellPadding –
• CellStyle –
• ColumnStyle –
• ColumnsPresenterStyle –
• GridLineBrush –
• GridLineWidth –
• HeaderBackground –
• HeaderClickBehavior –
• HeaderClickMode –
• HorizontalAlignment –
• HorizontalContentAlignment –
• IsContextMenuEnabled –
• Padding – This sets the padding aplied to all the column headers.
• ShowGridLines -
• ShowHeader –
• VerticalContentAlignment –

ColumnDefinition

ColumnDefinition exports a single event: PropertyChanged. The handler type for PropertyChanged is DependencyPropertyChangedEventHandler.

The following CLR properties are exposed on ColumnDefinition:

• AutoSizePadding – A double which is added to a cell’s desired size when performing auto size for the column.
• AutoSizeToFitContent – When true, the column’s width will automatically be increased as needed so that cells’ content is fully visible. Ignored if the column’s Width is not Auto.
• Binding – Defines the binding used for a cell’s content property. By default this value is set at runtime based on the value of BindingMemberPath.
• Id – A string. Not used. Provided for client use only.
• IndexInParent – Gets the index of the column within the parent ColumnDefinitionCollection.
• ParentCollection – Access a reference to the ColumnDefinitionCollection which contains the column definition.

Here is the list of dependency properties available on ColumnDefinition:

• AllowColumnResize –
• Background –
• BeginEditTriggerMode –
• BindingMemberPath –
• CellContentTemplate -
• CellEditorStyle –
• CellEditTemplate –
• CellForeground –
• CellHorizontalContentAlignment –
• CellIsEditable –
• CellIsSelectable –
• CellPadding –
• CellStyle –
• CellVerticalContentAlignment –
• ColumnSort –
• EditorSettings –
• GridLineBrush –
• GridLineWidth –
• Header –
• HeaderTemplate –
• HeaderBackground –
• HeaderBorderThickness –
• HeaderClickBehavior –
• HeaderClickMode –
• HorizontalContentAlignment –
• IsCellSelectedWithin –
• IsLocked –
• IsSelectable –
• IsSelected –
• Pin –
• Padding –
• PresenterStyle –
• ShowHeader –
• SortPriorityLevel –
• StringFormat –
• Width –
• VerticalContentAlignment –
• Visibility –

Editing

To enable in cell editing, set CellIsEditable = true on the coresponding column definition. Alternately, property IsEditable on AdvGridCell can be set, through a style setter or directly. Nothing else is required to enable editing with the default editor, which is basically a text box. (Except for booleans and enumerations. The default editor for bool values is a check box. For enums it is a combo box.)

Actual editing is performed by a ContentEditingControl which is embedded in the default Template for AdvGridCell. The content editing control is also responsible for displaying the cell’s content when not being edited.

There are several built-in editors, in addition to the default editor, each of which targets a specific data types. Assigning one of these editors to a column or cell is simply a matter of setting property EditorSettings to an instance of the class, derived from DevComponents.WPF.Controls.EditorSettings, which maps to the desired editor.

All built-in editors, including the default editor, have a set of options which are exposed as properties of the coresponding EditorSettings class.

For examples in Xaml, see the Xaml example for ColumnDefinitionCollection above.

If none of the built-in editors satisfies your requirements, a custom editor can be created by defining a new Style for the EditingContentControl. The style can be applied by setting it as the value of the property CellEditorStyle of the column definition, or as the value of property EditorStyle of the AdvCellControl. The EditorSettings class also has a property EditorStyle. More information about EditingContentControl is provided below.

EditorSettings

EditorSettings is based on System.Attribute, making it possible to define and customize a property’s editor directly on the property definition itself.

Following are the properties defined on the base class EditorSettings. Each of these properties represents an option common to all or most of the built-in editors. An important thing to note is that the control which does the editing (an instance of EditingContentControl) is also responsible for presenting the cell’s content when it is not in edit mode. For this reason, some of these properties affect the cell’s content when not in edit mode.

• AlwaysShowTextBox – Primarily used when the editor has a button, determies whether the button is sized to occupy the entire cell or only a portion of it, leaving room for a text box containing the value text.
• AutoComplete – An enumeration of type AutoCompleteOptions which defines auto complete options for text based editing. AutoCompleteOptions has the Flags attribute set. Possible values are:
  • Off – Auto complete is not enabled. This is the default.
  • ReadOnly – Auto complete is enabled. Only values in the auto complete list are allowed.
  • FreeText – Auto complete is enabled. The user is allowed to enter any text.
  • DontConvertCase – When auto complete is enabled, suggestions are case sensitive.
• AutoCompleteList – Provides a list of possible values for auto complete. Required if auto complete is enabled.
• DisplayMemberPath – If a cell’s data object is a complex object (i.e. it has properties of its own) then this property can be used to identify the path to the property which defines the text to display for the cell.
• EditorStyle – A Style which, if set, is applied to the EditingContentControl.
• EditorStyleResourceKey – A string which is the key of a discoverable resource defining a Style which is applied to the EditingContentControl. This property is specifically intended for when the EditorSettings are being applied as an Attribute to the property which serves as the data source for the cell/column.
• IsInCellEditingEnabled – Determies whether the user can edit the cell’s value directly in the text box.
• IsButtonHighlightedOnMouseOver – When true, buttons are highlighted when the mouse is over them.
• Mask – A string which defines a mask to use on the cell’s string value. For more information see MaskedTextProvider documentation on MSDN.
• NullValueDisplayValue – Specifies string to display for the null value.
• PropertyType – The Type of the property being edited. By default, this value is obtained at run-time using reflection.
• StringFormat – A format string applied to the cell’s string value.
• TypeConverter – A System.ComponentModel.TypeConverter which if set is used to convert between the object being edited and the string representation of the object.
• ValidationRules – A list of System.Windows.Controls.ValidationRule objects. Rules added to this list are added to the Binding which binds the cell’s content property.

Following are the editor settings classes for the built-in editors that are available at this time. They are all derived from EditorSettings.

BooleanEditorSettings

Used with the built-in boolean editor. Defines the following properties:

<ControlTemplate TargetType="{x:Type dc:AdvGrid}">
    <Border Padding="{TemplateBinding Padding}" BorderBrush="{TemplateBinding BorderBrush}" BorderThickness="{TemplateBinding BorderThickness}" Background="{TemplateBinding Background}">
        <Grid Name="MainGrid">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="Auto" />
                <ColumnDefinition />
            </Grid.ColumnDefinitions>
            <Grid.RowDefinitions>
                <RowDefinition Height="Auto"/>
                <RowDefinition />
            </Grid.RowDefinitions>
            <Grid Height="{Binding ElementName=ColumnsPresenter, Path=HeaderHeight}">
                <dc:AdvGridHeaderCorner x:Name="HeaderCorner" Width="{Binding RelativeSource={RelativeSource TemplatedParent}, Path=RowHeaderWidth, Mode=TwoWay}" />
            </Grid>
            <dc:ColumnsPresenter x:Name="ColumnsPresenter" Grid.Column="1" Grid.RowSpan="2"
                                ItemsSource="{Binding RelativeSource={RelativeSource TemplatedParent}, Path=ColumnDefinitions}"
                                dc:DragDrop.DragAdornerTemplate="{DynamicResource {x:Static dc:AdvGrid.ColumnHeaderDragAdornerTemplateKey}}"
                                dc:DragDrop.DropAdornerTemplate="{DynamicResource {x:Static dc:AdvGrid.ColumnHeaderDropAdornerTemplateKey}}" />
            <ScrollViewer Name="ScrollViewer" Grid.ColumnSpan="2" Grid.Row="1" Padding="0,-1,0,0" Focusable="False" CanContentScroll="True" ClipToBounds="False"
                            IsDeferredScrollingEnabled="{TemplateBinding ScrollViewer.IsDeferredScrollingEnabled}">
                <dc:AdvGridPanel x:Name="ItemsHost" Margin="0,1,0,0" />
            </ScrollViewer>
            <TextBlock Name="InitializingMessage" Grid.Row="1" Grid.Column="1" Opacity="0" HorizontalAlignment="Center" VerticalAlignment="Center"
                        Text="{DynamicResource {x:Static dc:AdvGrid.DataInitializingMessageStringKey}}"/>
            <dc:PinnedColumnsSeparator Pin="Left" Grid.Column="1" Grid.RowSpan="2" Visibility="Collapsed" HorizontalAlignment="Left" />
            <dc:PinnedColumnsSeparator Pin="Right" Grid.Column="1" Grid.RowSpan="2" Visibility="Collapsed" HorizontalAlignment="Left" />
        </Grid>
        <VisualStateManager.VisualStateGroups>
            <VisualStateGroup Name="VirtualizingDataStates">
                <VisualState Name="DataInitialized" />
                <VisualState Name="DataInitializing">
                    <Storyboard>
                        <DoubleAnimation Storyboard.TargetName="InitializingMessage" Storyboard.TargetProperty="Opacity" Duration="0" To="1" />
                    </Storyboard>
                </VisualState>
            </VisualStateGroup>
        </VisualStateManager.VisualStateGroups>
    </Border>
    <ControlTemplate.Triggers>
        <Trigger Property="ShowRowHeaders" Value="False">
            <Setter TargetName="HeaderCorner" Property="Visibility" Value="Collapsed" />
        </Trigger>
    </ControlTemplate.Triggers>
</ControlTemplate>

<ControlTemplate TargetType="dc:AdvGridHeaderCorner">
    <Grid Background="{TemplateBinding Background}">
        <Border BorderThickness="{TemplateBinding BorderThickness}" BorderBrush="{TemplateBinding BorderBrush}" />
        <Polygon Name="Glyph" Points="10,0 10,10 0,10" Margin="5" HorizontalAlignment="Right" VerticalAlignment="Bottom" Stretch="Uniform" RenderTransformOrigin="0.5,0.5"
                    Fill="{DynamicResource {x:Static dc:AdvGrid.HeaderCornerGlyphBrushKey}}">
            <Polygon.RenderTransform>
                <RotateTransform x:Name="GlyphTransform" Angle="0" />
            </Polygon.RenderTransform>
        </Polygon>
        <Thumb Background="Transparent" Width="4" HorizontalAlignment="Right" VerticalAlignment="Stretch" Cursor="SizeWE" BorderBrush="Transparent"
                Visibility="{Binding RelativeSource={RelativeSource AncestorType=dc:AdvGrid}, Path=LockRowHeaderWidth, Converter={StaticResource boolToVisibilityConverter}, ConverterParameter=Inverse}">
            <Thumb.Template>
                <ControlTemplate>
                    <Grid Background="Transparent" />
                </ControlTemplate>
            </Thumb.Template>
        </Thumb>
        <VisualStateManager.VisualStateGroups>
            <VisualStateGroup Name="CheckedStates">
                <VisualState Name="Unchecked" />
                <VisualState Name="Checked">
                    <Storyboard>
                        <DoubleAnimation Storyboard.TargetName="GlyphTransform" Storyboard.TargetProperty="Angle" Duration="0" To="180" />
                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="Glyph" Storyboard.TargetProperty="HorizontalAlignment">
                            <DiscreteObjectKeyFrame KeyTime="0" Value="{x:Static HorizontalAlignment.Left}" />
                        </ObjectAnimationUsingKeyFrames>
                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="Glyph" Storyboard.TargetProperty="VerticalAlignment">
                            <DiscreteObjectKeyFrame KeyTime="0" Value="{x:Static VerticalAlignment.Top}" />
                        </ObjectAnimationUsingKeyFrames>
                    </Storyboard>
                </VisualState>
            </VisualStateGroup>
        </VisualStateManager.VisualStateGroups>
    </Grid>
</ControlTemplate>

<ControlTemplate TargetType="dc:AdvGridRow">
    <Grid Background="Transparent">
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="Auto" />
            <ColumnDefinition />
        </Grid.ColumnDefinitions>
 
        <dc:AdvGridRowHeader x:Name="RowHeader" Content="{TemplateBinding Header}" ContentTemplate="{TemplateBinding HeaderTemplate}"
                                Width="{Binding RelativeSource={RelativeSource TemplatedParent}, Path=ParentTable.RowHeaderWidth}" 
                                Visibility="{Binding RelativeSource={RelativeSource TemplatedParent}, Path=ParentTable.ShowRowHeaders, Converter={StaticResource boolToVisibilityConverter}}" />
 
        <Border Grid.Column="1" BorderBrush="{TemplateBinding BorderBrush}" BorderThickness="{TemplateBinding BorderThickness}" Background="{TemplateBinding Background}" />
        <Border Name="HighlightBorder" Grid.Column="1" Opacity="0" Background="{DynamicResource {x:Static dc:AdvGridRow.HighlightBackgroundKey}}" />
        <Border Name="SelectionBorder" Grid.Column="1" Opacity="0" Background="{DynamicResource {x:Static dc:AdvGridRow.SelectedBackgroundKey}}" />
        <Border Name="SelectedInactiveBorder" Grid.Column="1" Opacity="0" Background="{DynamicResource {x:Static dc:AdvGridRow.SelectedInactiveBackgroundKey}}" />
 
        <Border Name="CellsBorder" Grid.Column="1" BorderBrush="{TemplateBinding HorizontalGridLineBrush}" 
                BorderThickness="{Binding RelativeSource={RelativeSource TemplatedParent}, Path=HorizontalGridLineHeight, Converter={StaticResource doubleToThicknessConverter}, ConverterParameter=Bottom}">
            <dc:AdvCellPanel x:Name="CellPanel" />
        </Border>
        <Rectangle Name="FocusRect" Grid.Column="1" Opacity="0" Stroke="Black" StrokeDashArray="1,2" SnapsToDevicePixels="True" />
 
        <!-- Use a Cell here to ensure height of row when loading matches height of row when loaded. -->
        <dc:AdvGridCell x:Name="LoadingMessage" Visibility="Collapsed" Grid.Column="1" VerticalContentAlignment="Center" HorizontalAlignment="Left" 
                        Margin="20,0,0,0" Content="{DynamicResource {x:Static dc:AdvGridRow.DataLoadingMessageStringKey}}" />
 
        <VisualStateManager.VisualStateGroups>
            <VisualStateGroup Name="SelectionStates">
                <VisualState Name="Unselected" />
                <VisualState Name="Selected">
                    <Storyboard>
                        <DoubleAnimation Storyboard.TargetName="SelectionBorder" Storyboard.TargetProperty="Opacity" To="1" Duration="0" />
                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="FocusRect" Storyboard.TargetProperty="Visibility">
                            <DiscreteObjectKeyFrame KeyTime="0" Value="{x:Static Visibility.Collapsed}" />
                        </ObjectAnimationUsingKeyFrames>
                    </Storyboard>
                </VisualState>
                <VisualState Name="CellSelectedWithin" />
                <VisualState Name="CellSelectedWithinInactive" />
                <VisualState Name="AllColumnsSelected" />
                <VisualState Name="AllColumnsSelectedInactive" />
                <VisualState Name="SelectedInactive">
                    <Storyboard>
                        <DoubleAnimation Storyboard.TargetName="SelectedInactiveBorder" Storyboard.TargetProperty="Opacity" To="1" Duration="0" />
                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="FocusRect" Storyboard.TargetProperty="Visibility">
                            <DiscreteObjectKeyFrame KeyTime="0" Value="{x:Static Visibility.Collapsed}" />
                        </ObjectAnimationUsingKeyFrames>
                    </Storyboard>
                </VisualState>
            </VisualStateGroup>
            <VisualStateGroup Name="HighlightedStates">
                <VisualState Name="NotHighlighted" />
                <VisualState Name="IsHighlighted">
                    <Storyboard>
                        <DoubleAnimation Storyboard.TargetName="HighlightBorder" Storyboard.TargetProperty="Opacity" To="1" Duration="0" />
                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="FocusRect" Storyboard.TargetProperty="Visibility">
                            <DiscreteObjectKeyFrame KeyTime="0" Value="{x:Static Visibility.Collapsed}" />
                        </ObjectAnimationUsingKeyFrames>
                    </Storyboard>
                </VisualState>
            </VisualStateGroup>
            <VisualStateGroup Name="FocusStates">
                <VisualState Name="Unfocused" />
                <VisualState Name="Focused">
                    <Storyboard>
                        <DoubleAnimation Storyboard.TargetName="FocusRect" Storyboard.TargetProperty="Opacity" Duration="0" To="1" />
                    </Storyboard>
                </VisualState>
            </VisualStateGroup>
        </VisualStateManager.VisualStateGroups>
    </Grid>
    <ControlTemplate.Triggers>
        <Trigger Property="ShowHorizontalGridLines" Value="False">
            <Setter TargetName="CellsBorder" Property="BorderThickness" Value="0" />
        </Trigger>
        <Trigger Property="IsDataLoading" Value="True">
            <Setter TargetName="CellPanel" Property="Opacity" Value="0" />
            <Setter TargetName="LoadingMessage" Property="Visibility" Value="Visible" />
        </Trigger>
    </ControlTemplate.Triggers>
</ControlTemplate>

<ControlTemplate TargetType="dc:AdvGridRowHeader">
    <Grid Background="{TemplateBinding Background}">
        <Border BorderThickness="{TemplateBinding BorderThickness}" BorderBrush="{TemplateBinding BorderBrush}">
            <Grid>
                <Border Name="CellSelectedBorder" Opacity="0" Margin="0,-1,-1,-1" BorderThickness="0,1,1,1" 
                        BorderBrush="{DynamicResource {x:Static dc:AdvGridRow.CellSelectedHeaderBorderBrushKey}}" Background="{DynamicResource {x:Static dc:AdvGridRow.CellSelectedHeaderBackgroundKey}}" />
                <Border Name="RowSelectedBorder" Opacity="0" Margin="0,-1,-1,-1" BorderThickness="0,1,1,1" 
                        BorderBrush="{DynamicResource {x:Static dc:AdvGridRow.RowSelectedHeaderBorderBrushKey}}" Background="{DynamicResource {x:Static dc:AdvGridRow.RowSelectedHeaderBackgroundKey}}" />
                <Border Name="SelectedInactiveBorder" Opacity="0" Margin="0,-1,-1,-1" BorderThickness="0,1,1,1" 
                        BorderBrush="{DynamicResource {x:Static dc:AdvGridRow.SelectedInactiveHeaderBorderBrushKey}}" Background="{DynamicResource {x:Static dc:AdvGridRow.SelectedInactiveHeaderBackgroundKey}}" />
                <Border Name="HighlightBorder"  Opacity="0" Margin="0,-1,-1,-1" BorderThickness="0,1,1,1" 
                        BorderBrush="{DynamicResource {x:Static dc:AdvGridRow.HighlightHeaderBorderBrushKey}}" Background="{DynamicResource {x:Static dc:AdvGridRow.HighlightHeaderBackgroundKey}}" />
                <ContentPresenter Name="Presenter" Margin="{TemplateBinding Padding}" HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}" VerticalAlignment="{TemplateBinding VerticalContentAlignment}" />
                <Path Name="FocusGlyph" Opacity="0" Style="{DynamicResource {x:Static dc:AdvGridRow.HeaderSelectedGlyphStyleKey}}" />
            </Grid>
        </Border>
        <Thumb HorizontalAlignment="Stretch" VerticalAlignment="Bottom" Height="3" Cursor="SizeNS" Template="{StaticResource RowHeaderThumbTemplate}"
                Visibility="{Binding RelativeSource={RelativeSource AncestorType=dc:AdvGridRow}, Path=LockHeight, Converter={StaticResource boolToVisibilityConverter}, ConverterParameter=Inverse}" />
        <Thumb VerticalAlignment="Stretch" HorizontalAlignment="Right" Width="3" Cursor="SizeWE" Template="{StaticResource RowHeaderThumbTemplate}"
                Visibility="{Binding RelativeSource={RelativeSource AncestorType=dc:AdvGrid}, Path=LockRowHeaderWidth, Converter={StaticResource boolToVisibilityConverter}, ConverterParameter=Inverse}" />
        <VisualStateManager.VisualStateGroups>
            <VisualStateGroup Name="CommonStates">
                <VisualState Name="Normal" />
                <VisualState Name="Disabled" />
                <VisualState Name="Highlighted">
                    <Storyboard>
                        <DoubleAnimation Storyboard.TargetName="HighlightBorder" Storyboard.TargetProperty="Opacity" Duration="0" To="1" />
                    </Storyboard>
                </VisualState>
            </VisualStateGroup>
            <VisualStateGroup Name="FocusStates">
                <VisualState Name="RowUnfocused" />
                <VisualState Name="RowFocused">
                    <Storyboard>
                        <DoubleAnimation Storyboard.TargetName="FocusGlyph" Storyboard.TargetProperty="Opacity" Duration="0" To="1" />
                    </Storyboard>
                </VisualState>
            </VisualStateGroup>
            <VisualStateGroup Name="SelectionStates">
                <VisualState Name="Unselected" />
                <VisualState Name="Selected">
                    <Storyboard>
                        <DoubleAnimation Storyboard.TargetName="RowSelectedBorder" Storyboard.TargetProperty="Opacity" Duration="0" To="1" />
                    </Storyboard>
                </VisualState>
                <VisualState Name="CellSelectedWithin">
                    <Storyboard>
                        <DoubleAnimation Storyboard.TargetName="CellSelectedBorder" Storyboard.TargetProperty="Opacity" Duration="0" To="1" />
                    </Storyboard>
                </VisualState>
                <VisualState Name="AllColumnsSelected">
                    <Storyboard>
                        <DoubleAnimation Storyboard.TargetName="RowSelectedBorder" Storyboard.TargetProperty="Opacity" Duration="0" To="1" />
                    </Storyboard>
                </VisualState>
                <VisualState Name="SelectedInactive">
                    <Storyboard>
                        <DoubleAnimation Storyboard.TargetName="SelectedInactiveBorder" Storyboard.TargetProperty="Opacity" Duration="0" To="1" />
                    </Storyboard>
                </VisualState>
                <VisualState Name="CellSelectedWithinInactive">
                    <Storyboard>
                        <DoubleAnimation Storyboard.TargetName="SelectedInactiveBorder" Storyboard.TargetProperty="Opacity" Duration="0" To="1" />
                    </Storyboard>
                </VisualState>
                <VisualState Name="AllColumnsSelectedInactive">
                    <Storyboard>
                        <DoubleAnimation Storyboard.TargetName="SelectedInactiveBorder" Storyboard.TargetProperty="Opacity" Duration="0" To="1" />
                    </Storyboard>
                </VisualState>
            </VisualStateGroup>
        </VisualStateManager.VisualStateGroups>
    </Grid>
</ControlTemplate>

<ControlTemplate TargetType="dc:AdvGridCell">
    <Grid Name="MainGrid" Background="Transparent">
        <Grid.ColumnDefinitions>
            <ColumnDefinition />
            <ColumnDefinition Width="Auto" />
        </Grid.ColumnDefinitions>
        <Border BorderBrush="{TemplateBinding BorderBrush}" BorderThickness="{TemplateBinding BorderThickness}" Background="{TemplateBinding Background}" />
        <Border Name="SelectedBorder" Opacity="0" BorderThickness="{TemplateBinding BorderThickness}" 
                BorderBrush="{DynamicResource {x:Static dc:AdvGridCell.IsSelectedBorderBrushKey}}" Background="{DynamicResource {x:Static dc:AdvGridCell.IsSelectedBackgroundKey}}" />
        <Border Name="InactiveSelectedBorder" Opacity="0" BorderThickness="{TemplateBinding BorderThickness}" 
                BorderBrush="{DynamicResource {x:Static dc:AdvGridCell.SelectedInactiveBorderBrushKey}}" Background="{DynamicResource {x:Static dc:AdvGridCell.SelectedInactiveBackgroundKey}}" />
        <Border Name="HighlightBorder" Opacity="0" BorderThickness="{TemplateBinding BorderThickness}" 
                BorderBrush="{DynamicResource {x:Static dc:AdvGridCell.IsHighlightedBorderBrushKey}}" Background="{DynamicResource {x:Static dc:AdvGridCell.IsHighlightedBackgroundKey}}" />
        <Rectangle Name="GridLine" Grid.Column="1" VerticalAlignment="Stretch"
                    Visibility="{Binding RelativeSource={RelativeSource TemplatedParent}, Path=CellDefinition.ParentCollection.ShowGridLines, Converter={StaticResource boolToVisibilityConverter}}"
                    Fill="{Binding RelativeSource={RelativeSource TemplatedParent}, Path=CellDefinition.GridLineBrush}" 
                    Width="{Binding RelativeSource={RelativeSource TemplatedParent}, Path=CellDefinition.GridLineWidth}" />
        <dc:EditingContentControl x:Name="Editor" Margin="-1" Style="{TemplateBinding EditorStyle}" Validation.ErrorTemplate="{TemplateBinding Validation.ErrorTemplate}"
                                    Padding="{Binding RelativeSource={RelativeSource TemplatedParent}, Path=Padding, Converter={StaticResource additionConverter}, ConverterParameter=1}"
                                    VerticalContentAlignment="{TemplateBinding VerticalContentAlignment}" HorizontalContentAlignment="{TemplateBinding HorizontalContentAlignment}"
                                    EditorSettings="{Binding RelativeSource={RelativeSource TemplatedParent}, Path=CellDefinition.EditorSettings}"
                                    ContentTemplate="{TemplateBinding ContentTemplate}" ContentStringFormat="{TemplateBinding ContentStringFormat}"
                                    Content="{Binding RelativeSource={RelativeSource TemplatedParent}, Path=Content, Mode=TwoWay, UpdateSourceTrigger=Explicit}" />
        <VisualStateManager.VisualStateGroups>
            <VisualStateGroup Name="CommonStates">
                <VisualState Name="Normal" />
                <VisualState Name="Disabled" />
                <VisualState Name="Highlighted">
                    <Storyboard>
                        <DoubleAnimation Storyboard.TargetName="HighlightBorder" Storyboard.TargetProperty="Opacity" Duration="00:00:00.03" To="1" />
                    </Storyboard>
                </VisualState>
            </VisualStateGroup>
            <VisualStateGroup Name="SelectionStates">
                <VisualState Name="Unselected" />
                <VisualState Name="Selected">
                    <Storyboard>
                        <DoubleAnimation Storyboard.TargetName="SelectedBorder" Storyboard.TargetProperty="Opacity" Duration="00:00:00.03" To="1" />
                    </Storyboard>
                </VisualState>
                <VisualState Name="SelectedByColumn">
                    <Storyboard>
                        <DoubleAnimation Storyboard.TargetName="SelectedBorder" Storyboard.TargetProperty="Opacity" Duration="00:00:00.03" To="1" />
                    </Storyboard>
                </VisualState>
                <VisualState Name="SelectedInactive">
                    <Storyboard>
                        <DoubleAnimation Storyboard.TargetName="InactiveSelectedBorder" Storyboard.TargetProperty="Opacity" Duration="00:00:00.03" To="1" />
                    </Storyboard>
                </VisualState>
            </VisualStateGroup>                            
        </VisualStateManager.VisualStateGroups>
    </Grid>
</ControlTemplate>

<ControlTemplate TargetType="{x:Type ctrls:ColumnsPresenter}">
    <Grid Name="MainGrid">
        <Grid.ContextMenu>
            <ContextMenu ItemsSource="{Binding RelativeSource={RelativeSource TemplatedParent}, Path=ColumnDefinitions}" 
                            ItemContainerStyle="{DynamicResource {x:Static ctrls:ColumnsPresenter.ContextMenuItemStyleKey}}" />
        </Grid.ContextMenu>
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto" />
            <RowDefinition />
        </Grid.RowDefinitions>
        <ContentPresenter Name="Label" Content="{TemplateBinding Label}" ContentTemplate="{TemplateBinding LabelTemplate}" />
        <Border Grid.Row="1" BorderThickness="{TemplateBinding BorderThickness}" BorderBrush="{TemplateBinding BorderBrush}">
            <Grid>
                <Rectangle VerticalAlignment="Top" Height="{TemplateBinding HeaderHeight}" Fill="{TemplateBinding HeaderBackground}" />
                <ItemsPresenter />
                <Border VerticalAlignment="Top" Height="{TemplateBinding HeaderHeight}" BorderBrush="{TemplateBinding BorderBrush}" BorderThickness="{TemplateBinding HeaderBorderThickness}" />
            </Grid>
        </Border>
    </Grid>
    <ControlTemplate.Triggers>
        <DataTrigger Binding="{Binding RelativeSource={RelativeSource TemplatedParent}, Path=ColumnDefinitions.IsContextMenuEnabled}" Value="False">
            <Setter TargetName="MainGrid" Property="Grid.ContextMenu" Value="{x:Null}" />
        </DataTrigger>
    </ControlTemplate.Triggers>
</ControlTemplate>

<ControlTemplate TargetType="ctrls:ColumnPresenter">
    <Grid Background="Transparent" SnapsToDevicePixels="True">
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto" />
            <RowDefinition />
        </Grid.RowDefinitions>
        <ctrls:ColumnHeader x:Name="Header" Visibility="{Binding ShowHeader, Converter={StaticResource boolToVisibilityConverter}}" />
        <Thumb Name="ResizeThumb" Width="6" HorizontalAlignment="Right" Cursor="SizeWE" 
                Visibility="{Binding AllowColumnResize, Converter={StaticResource boolToVisibilityConverter}}">
            <Thumb.Template>
                <ControlTemplate>
                    <Grid Background="Transparent" />
                </ControlTemplate>
            </Thumb.Template>
        </Thumb>
        <Border Name="ColumnBorder" Grid.Row="1" Background="{TemplateBinding Background}" BorderThickness="{TemplateBinding BorderThickness}" BorderBrush="{TemplateBinding BorderBrush}" />
        <Rectangle Grid.Row="1" HorizontalAlignment="Right" VerticalAlignment="Top"
                    Height="{Binding RelativeSource={RelativeSource AncestorType=ctrls:AdvTabularControl}, Path=Padding, Converter={StaticResource thicknessToDoubleConverter}, ConverterParameter=Top}" 
                    Fill="{Binding GridLineBrush}" Width="{Binding GridLineWidth}" />
    </Grid>
    <ControlTemplate.Triggers>
        <Trigger Property="Pin" Value="Right">
            <Setter TargetName="ResizeThumb" Property="HorizontalAlignment" Value="Left" />
            <Setter TargetName="ResizeThumb" Property="Margin" Value="-6,0,0,0" />
        </Trigger>
    </ControlTemplate.Triggers>
</ControlTemplate>

<ControlTemplate TargetType="ctrls:ColumnHeader">
    <ControlTemplate.Resources>
    </ControlTemplate.Resources>
    <Grid Background="Transparent">
        <Border Background="{TemplateBinding Background}" BorderThickness="{TemplateBinding BorderThickness}" BorderBrush="{TemplateBinding BorderBrush}" />
        <Border Name="CellSelectedBorder" Margin="-1,0,0,0" Opacity="0" BorderThickness="1,0,1,1" BorderBrush="{DynamicResource {x:Static ctrls:ColumnPresenter.CellSelectedHeaderBorderBrushKey}}"
                Background="{DynamicResource {x:Static ctrls:ColumnPresenter.CellSelectedHeaderBackgroundKey}}" />
        <Border Name="ColumnSelectedBorder" Margin="-1,0,0,0" Opacity="0" BorderThickness="1,0,1,1" BorderBrush="{DynamicResource {x:Static ctrls:ColumnPresenter.ColumnSelectedHeaderBorderBrushKey}}"
                Background="{DynamicResource {x:Static ctrls:ColumnPresenter.ColumnSelectedHeaderBackgroundKey}}" />
        <Border Name="SelectedInactiveBorder" Margin="-1,0,0,0" Opacity="0" BorderThickness="1,0,1,1" BorderBrush="{DynamicResource {x:Static ctrls:ColumnPresenter.SelectedInactiveHeaderBorderBrushKey}}"
                Background="{DynamicResource {x:Static ctrls:ColumnPresenter.SelectedInactiveHeaderBackgroundKey}}" />
        <Border Name="PressedBorder" Margin="-1,0,0,0" Opacity="0" BorderThickness="1,0,1,1" BorderBrush="{DynamicResource {x:Static ctrls:ColumnPresenter.HeaderHighlightBorderBrushKey}}"
                Background="{DynamicResource {x:Static ctrls:ColumnPresenter.HeaderPressedBackgroundKey}}" />
        <Border Name="HighlightBorder" Margin="-1,0,0,0" Opacity="0" BorderThickness="1,0,1,1" BorderBrush="{DynamicResource {x:Static ctrls:ColumnPresenter.HeaderHighlightBorderBrushKey}}"
                Background="{DynamicResource {x:Static ctrls:ColumnPresenter.HeaderHighlightBackgroundKey}}" />
        <ContentPresenter Name="Presenter" Margin="{TemplateBinding Padding}" 
                            HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}" VerticalAlignment="{TemplateBinding VerticalContentAlignment}" />
        <Control Name="SortGlyph" Grid.Column="1" Style="{DynamicResource {x:Static ctrls:ColumnPresenter.ColumnSortGlyphStyleKey}}" />
        <VisualStateManager.VisualStateGroups>
            <VisualStateGroup Name="CommonStates">
                <VisualState Name="Normal" />
                <VisualState Name="Disabled" />
                <VisualState Name="Highlighted">
                    <Storyboard>
                        <DoubleAnimation Storyboard.TargetName="HighlightBorder" Storyboard.TargetProperty="Opacity" Duration="0" To="1" />
                    </Storyboard>
                </VisualState>
                <VisualState Name="Pressed">
                    <Storyboard>
                        <DoubleAnimation Storyboard.TargetName="PressedBorder" Storyboard.TargetProperty="Opacity" Duration="0" To="1" />
                    </Storyboard>
                </VisualState>
            </VisualStateGroup>
            <VisualStateGroup Name="SelectionStates">
                <VisualState Name="Unselected" />
                <VisualState Name="ColumnSelected">
                    <Storyboard>
                        <DoubleAnimation Storyboard.TargetName="ColumnSelectedBorder" Storyboard.TargetProperty="Opacity" Duration="0" To="1" />
                    </Storyboard>
                </VisualState>
                <VisualState Name="CellSelectedWithin">
                    <Storyboard>
                        <DoubleAnimation Storyboard.TargetName="CellSelectedBorder" Storyboard.TargetProperty="Opacity" Duration="0" To="1" />
                    </Storyboard>
                </VisualState>
                <VisualState Name="SelectedInactive">
                    <Storyboard>
                        <DoubleAnimation Storyboard.TargetName="SelectedInactiveBorder" Storyboard.TargetProperty="Opacity" Duration="0" To="1" />
                    </Storyboard>
                </VisualState>
            </VisualStateGroup>
        </VisualStateManager.VisualStateGroups>
    </Grid>
</ControlTemplate>

<Style x:Key="{x:Static ctrls:ColumnsPresenter.ContextMenuItemStyleKey}" TargetType="MenuItem">
    <Style.Resources>
        <ctrls:VisibilityToBooleanConverter x:Key="visibilityToBoolConverter" />
    </Style.Resources>
    <Setter Property="Foreground" Value="{DynamicResource {x:Static ctrls:MenuResources.MenuItemForegroundKey}}" />
    <Setter Property="Padding" Value="{DynamicResource {x:Static ctrls:MenuResources.MenuItemPaddingKey}}" />
    <Setter Property="IsCheckable" Value="True" />
    <Setter Property="IsChecked" Value="{Binding Visibility, Converter={StaticResource visibilityToBoolConverter}, Mode=TwoWay}" />
    <Setter Property="Header" Value="{Binding Header}" />
    <Style.Triggers>
        <DataTrigger Binding="{Binding IsLocked}" Value="True">
            <Setter Property="Visibility" Value="Collapsed" />
        </DataTrigger>
    </Style.Triggers>
</Style>

Related posts:

1. WPF Color Control Quick Start Guide
2. Brush Control Quick Start Guide
3. WPF AdvTree Quick Start Guide