Well, you can! The PropertyEditor class supports an EditContext property which you can set up on a per-property basis, and the editor DataTemplate can bind to this EditContext and customize the template based on its state. I’ll go into detail on the above case in the second part of this post, but first off let’s look at a simpler use case where the EditContext can be used to clean up your XAML, but which is a bit easier for demo purposes!

Imagine a case where we have a model with multiple integer properties representing specifications of some object, for instance personal computers. We’d like to display these in a DataGrid, and it’d be great if the user could change the value in a cell with a Slider (or UpDown control, etc). As the various properties have differing sensible ranges they would normally need their own template containing a unique Slider with its Minimum/Maximum/SmallChange set appropriately.

Instead of creating three separate templates we can set the EditContext of a PropertyEditor, and then bind to this from the template. Firstly, we’ll need a class to hold the values we need to vary between instances of the template. For our numeric editing example this is very simple:

public class ComputerEditInfo
{
  public int Maximum { get; set; }
  public int Minimum { get; set; }
  public int SmallChange { get; set; }
}

Then back in the XAML inside the DataGrid declaration, open a PropertyEditor tag and set its EditContext to be an instance of the above class. Here’s two out of three required:

<ms:DataGrid.Editors>
  <ms:PropertyEditor PropertyName="Ram"
                     EditorTemplate="{StaticResource NumericSliderCellTemplate}" >
    <ms:PropertyEditor.EditContext>
      <local:ComputerEditInfo Minimum="1" Maximum="8" SmallChange="1" />
    </ms:PropertyEditor.EditContext>
  </ms:PropertyEditor>
 
  <ms:PropertyEditor PropertyName="HardDrive"
                     EditorTemplate="{StaticResource NumericSliderCellTemplate}">
    <ms:PropertyEditor.EditContext>
      <local:ComputerEditInfo Minimum="120" Maximum="1024" SmallChange="120" />
    </ms:PropertyEditor.EditContext>                    
  </ms:PropertyEditor>
</ms:DataGrid.Editors>

Notice that we have to use the Editors collection instead of the Columns collection.

Now we can create our reusable DataTemplate. There are a couple of important things to be aware of when creating a reusable DataTemplate for use with a PropertyEditor.

First, because the template is going to be used for multiple properties, you can’t bind to the property by the actual property name on the originating object. Instead, the PropertyEditor plumbing presents the value being edited as Value, and that’s what you have to bind to in the editing control(s).

Second, the PropertyEditor plumbing also supplies an EditContext property that you can bind to. For any given instance of the editor template, this will contain the value of the EditContext in the PropertyEditor declaration that applies to the current instance.

Here’s the editor template for the numeric properties of the computer object:

<DataTemplate x:Key="NumericSliderCellTemplate">
  <Grid VerticalAlignment="Center" >
    <Grid.ColumnDefinitions>
      <ColumnDefinition Width="Auto" />
      <ColumnDefinition Width="*" />
      <ColumnDefinition Width="Auto" />
    </Grid.ColumnDefinitions>
    <TextBlock Text="{Binding EditContext.Minimum}"
               Margin="2,0,0,0"
               Foreground="#3D3D3D" />
    <Slider Value="{Binding Value, Mode=TwoWay}"
            Minimum="{Binding EditContext.Minimum}"
            Maximum="{Binding EditContext.Maximum}"
            SmallChange="{Binding EditContext.SmallChange}"
            Margin="2,0,2,0"
            Grid.Column="1"/>
    <TextBlock Text="{Binding EditContext.Maximum}"
               Grid.Column="2"
               Margin="0,0,4,0"
               Foreground="#3D3D3D" />
  </Grid>
</DataTemplate>

Notice how the Slider and the TextBlocks bind to the EditContext to implement and display the correct per-property settings for minimum and maximum values and change size. One template for multiple columns, each with their values correctly set – that’s pretty clean! And here’s the output, where after the cell is double-clicked into edit mode the Slider appears set with the minimum and maximum.

This of course can be extended for passing in any sort of data that can be reused with adjustments across columns, and next time we’ll look at a detailed implementation of the ComboBox case, where its DisplayMemberPath and SelectedValuePath will update based on the various PropertyEditors set for the columns. Check out our site for more information on the DataGrid and the 50+ other controls included in WPF Elements 5. Until then!

WPF Elements

• Added handling for race conditions in DataGrid.BringCellIntoView and DataGrid.GetCell
• Fixed a bug in DataGrid.RemoveInputBinding
• Added DataGridColumn.AllowGrouping property, which allows you to specify that the user cannot group on that column
• You can now template DataGrid group row headers

Web Workbench

• Highlighting for Less pattern matching and guards
• Fix for file generation error when using checkout-based source control system
• Updated Less compiler to 1.2.1
• Improved positioning of opening braces during Format Document
• Fix for error with unbounded node (e.g. unclosed quote) in CoffeeScript

LightSpeed

• Apply COLLATE NOCASE when creating SQLite GUID primary keys
• Fixes relating to one-way associations when the originating side is a concrete table inheritance base class
• Fixed migrations error with abstract classes

WPF Diagrams

• Tweak to the ElbowPathfinder

As always the free editions are available on the downloads page and you can get the full editions from the store. Happy coding!

LightSpeed

• Exclude null associations from polymorphic association validation
• Fix for not being able to return array values from ICompiledParameterValues to populate an IN clause
• Fix for LINQ projection that included the result of a Count on a join-into result when there was no Where clause
• When updating a SQLite database with a GUID field, set COLLATE NOCASE on the column (because it is mapped as a string rather than a native GUID type)
• Added support for per-table identity block size (for when new tables use KeyTable but the database also contains legacy tables which are also updated by other apps using increment-by-1 sequences)

WPF Diagrams

• DiagramConnectionPointBase.OnPositionChanged is now exposed to user derived classes
• Fixed a bug in the ConnectionPointRelocation sample

WPF Elements

• DataGrid hotness!
• Fixed a bug in TimeExplorer

As usual, you can get the updated builds of free versions from the downloads page, and of full versions from the store.

There are many small improvements to the API, such as being able to scroll a particular DataGrid cell into view, as well as two significant additions to the DataGrid we’re sure you’ll find very handy – Grouping and Exporting support. For the rest of the post I’ll be discussing how you can use these two features. First up – grouping!

Grouping

Users can now group data by any number of columns through an intuitive drag-and-drop interface – just drag a column header onto the grouping panel above the grid. Groups can be expanded and collapsed as expected, and the column grouping can be be removed by clicking on a button that appears on mouseover. Any number of columns can be added to the panel and the DataGrid will group the data in a nested fashion. Check out the demo below:

Just set the IsGroupingPanelVisible property to True to enable the grouping UI. Alternatively, if you want to provide your own UI for grouping — or no UI at all, for example if you have an application where the data should always appear grouped — you can group on columns programatically by adding them to the GroupedColumns collection:

MyDataGrid.GroupedColumns.Add(MyDataGrid.EffectiveColumns[0]);

Easy as that. Our DataGrid performance is speedy even with millions of rows, and it stays that way even if the DataGrid has a complex nesting hierarchy.

Exporting

Another handy new feature is the ability to export the data in a DataGrid into an appropriate file format. At the moment we support the near-universal CSV format with more to come, and you can export to file, string or TextWriter. Again, it’s dead easy to use.

DataGridExporter.Csv.WriteFile(MyDataGrid, file);

In combination with a SaveFileDialog, you can export your DataGrid:

and have the resulting file be opened by Excel, complete with columns automatically generated by the DataGrid from your collections.

That saves time! These two features along with bugfixes are available in the nightly builds right now, but they’ll officially be available in the WPF Elements 5.1 soon. You can check out the 60 day trial of WPF Elements 5 here featuring the DataGrid control plus more than 50 others.

To begin, declare a new DataGrid control in a XAML page and bind its ItemsSource property to a collection in a similar manner to Working with the Data Grid – Day 1. If we are to add charts to this DataGrid its model will need a property of a type that contains an ObservableCollection of DateTimeDouble objects, which the LineGraph will use to draw itself. Here’s an archive with example data structures illustrating the required behavior (which generate random points suitable for the purposes of this demo): DataModel.

Setting up the sparkline charts

Next, in the ResourceDictionary add the following DataTemplates containing the formatted charts. The Chart control in WPF Elements 5 has heaps of customization options, and with a few simple tweaks the LineSeries can display a great looking Sparkline chart. Here’s one possible look for a Sparkline template:

<DataTemplate x:Key="BidChartCell">
  <ms:Chart LegendPosition="None" TitleTemplate="{x:Null}" Padding="3">
    <ms:LineSeries ItemsSource="{Binding BidTrend.Data1}" AlwaysShowYAxisZero="False" YAxisDataBuffer="1000" />
    <ms:Chart.XAxis >
      <ms:ChartAxis Visibility="Collapsed" />
    </ms:Chart.XAxis>
    <ms:Chart.YAxis>
      <ms:ChartAxis Visibility="Collapsed" />
    </ms:Chart.YAxis>
  </ms:Chart>
</DataTemplate>

The chart declared in that DataTemplate is going to look rather unnatural in any place larger than a DataGrid cell, so let’s apply it to a column in our DataGrid by setting its DisplayTemplate property:

<ms:DataGrid ItemsSource="{Binding Data}" AllowEditing="False">
  <ms:DataGrid.Columns>
    <ms:DataGridColumn PropertyName="BidTrend"
                       DisplayTemplate="{StaticResource BidChartCell}"
                       Header="Bid Trend"/>
  </ms:DataGrid.Columns>
</ms:DataGrid>

Pretty easy! If you were to increase the rows in the model you’d notice the performance is speedy even with dozens of charts on screen, and stays that way during resizing, dynamic data updating and similar tasks.

Showing additional data with template selectors

Now how about formatting the Change columns to show an image based on the data in each cell? One solution would be to create a custom class that derives from DataTemplateSelector and overrides SelectTemplate(). Here’s a snippet of the implementation with logic that returns a template based on whether the cell’s Double is positive or negative:

public class ChangeDataTemplateSelector : DataTemplateSelector
{
  public override DataTemplate SelectTemplate(object item, DependencyObject container)
  {
    FrameworkElement element = container as FrameworkElement;
 
    if (element != null && item != null)
    {
      Entry entryItem = item as Entry;
      if (ChangeType == CellChangeType.Bid)
      {
        if (entryItem.BidChange < 0)
        {
          return NegativeChangeTemplate;
        }
        else if (entryItem.BidChange > 0)
        {
          return PositiveChangeTemplate;
        }
      }
      else
      {
        if (entryItem.AskChange < 0)
        {
          return NegativeChangeTemplate;
        }
        else if (entryItem.AskChange > 0)
        {
          return PositiveChangeTemplate;
        }
      }
    }
    return NoChangeTemplate;
  }
 
  public DataTemplate PositiveChangeTemplate { get; set; }
}

The full code with the other two properties and the enum is contained in the archive at the bottom of this post. Back in the XAML, add the DataTemplates that are to be applied to the cell to the ResourceDictionary (here’s one of four required):

<DataTemplate x:Key="PositiveBidChangeTemplate">
  <Grid HorizontalAlignment="Center" x:Name="PositiveBidCell">
    <Grid.ColumnDefinitions>
      <ColumnDefinition Width="35" />
    <ColumnDefinition Width="20" />
    </Grid.ColumnDefinitions>
    <TextBlock Text="{Binding BidChange}" HorizontalAlignment="Right"
               VerticalAlignment="Center" Margin="0,0,6,0" />
    <Image Source="../Images/up.png" Width="16" Height="16" Grid.Column="1" />
  </Grid>
</DataTemplate>

We can now declare an instance of our DataTemplateSelector and set its properties to our DataTemplates. The Bid selector will look like this:

<local:ChangeDataTemplateSelector x:Key="BidChangeSelector"
                                  PositiveChangeTemplate="{StaticResource PositiveBidChangeTemplate}"
                                  NegativeChangeTemplate="{StaticResource NegativeBidChangeTemplate}"
                                  ChangeType="Bid"
                                  NoChangeTemplate="{StaticResource NoChangeBidTemplate}" />

Now that has been set up, it’s a simple matter of setting the DisplayTemplateSelector property on the appropriate DataGridColumn that you wish to apply the templates to. We may as well make the column’s title look a bit nicer at the same time.

<ms:DataGridColumn PropertyName="BidChange" Header="Bid Change"
                   DisplayTemplateSelector="{StaticResource BidChangeSelector}" />

That will get the Change and Trend columns looking like the screenshot at the top of this post. In a future post I’ll show how to extend the model to record the highest and lowest data, and use XAML triggers to format cells based upon that information. In the meantime, check out the archive below for the full code from this post.

DataGrid with sparklines and template selectors

And don’t forget to download the 60-day trial of WPF Elements and try out your own designs!

LightSpeed

• Fix for one-to-one association join chain in LINQ Where clauses
• Added support for negated boolean expressions in LINQ Any and All
• Fixed a memory leak with compiled FindById queries
• Validation errors now provide access to the validation rule instance
• Include schema in auto-joined tables being joined by an identifier expression
• Fixed automatic date-time range validation for Oracle
• Improved support for SQL Server 2008 TIME data type
• Fixed an issue where a query with criteria on the left and a logical combination on the right could be processed incorrectly
• Fix for DeletedOn column being incorrectly aliased in update/delete queries
• Added support for deleting by LINQ query
• Added Procedure and Scale options to ProcedureParameter class
• Fix for procedure parameters of user-defined types in designer being generated into wrapper function signatures as object instead of strongly typed
• Fix for value objects not being handled correctly in batch updates
• Fixed exception if you put DiscriminatorAttribute on a root entity class
• We now raise an exception if a SQL Server stored procedure calls RAISERROR (sic: what is this, guys, Fortran?) after performing a successful SELECT (previously only errors raised before the SELECT would cause exceptions)
• Added a property for migration code to access the connection string of the database being migrated
• When a stored procedure sets an out parameter to SQL NULL, we now translate this to CLR null instead of leaving it as DBNull.Value (this fixes casting errors in strong-typed wrapper methods)
• Fix for virtual (non-mapped) discriminators not being populated on insert
• Entity- and interface-level query filtering (in progress and subject to change)

Web Workbench

• Collapsing support for non-top-level regions
• Sass and Less Format Document command
• Fixed issue in Sass compilation if install path included non-ANSI characters
• Fixed JavaScript minifier mangling non-ANSI characters
• Upgraded CoffeeScript compiler to 1.2.0
• CoffeeScript comment highlighting fixes
• Comment/uncomment block support
• Performance improvements when making many deletes from a document
• Error checking and signature help for Sass and Less built-in functions

WPF Elements

• Continuing improvements to control themes
• Fixes for potential issues in TimeExplorer, Chart, ChartAxis and PieSeries
• Added option for rounding on lost focus in NumericTextBox
• Added ResetZoom command for charts
• MajorTickSpacing now keeps consistent tick density as user zooms
• Added PieSeries.SelectedDataPointChanged event
• Improvements to automatic bar chart width calculation
• Fixed error when changing chart highlight mode
• Fixed an issue with horizontal bar charts using categories along the Y axis
• Resolved a DataGrid issue
• Fixed foreground colours not being respected in CurrencyTextBox
• Fixed potential null reference error when changing DataGrid.ItemsSource
• Fixed some issues with chart default axes

WPF Diagrams

• Added TreeLayoutAlgorithm
• Fixed null reference error in ConnectionPointThumb
• Fixed a diagram binding issue
• Fix for a bug that was stealing mouse wheel and scroll events
• Added an option to turn off infinite scrolling

NHibernate Designer

• Added support for NHibernate sql-insert, sql-update and sql-delete overrides
• Added support for stored procedures and named SQL queries

SimpleDB Management Tools

• No longer need to click away from a row to ensure it is saved

As usual you can get the latest nightly builds from the Downloads page (free editions) or the store (full editions).

Make building better software your New Year’s resolution by taking advantage of our 30% sale on the Mega Pack.

For a limited time, pay only $699 and you’ll receive:

• LightSpeed O/R Mapper (normally $349)
• WPF Elements (normally $699)
• WPF Diagrams (normally $699)
• Silverlight Elements (normally $699)
• Phone Elements for WP7 (normally $299)
• NHibernate Designer (normally $99)
• SimpleDB Management Tools (normally $29)
• Web Workbench (normally $29)
• Visual Tools for SharePoint (normally $349)

Plus, you also get:

• 12 months of new releases, nightly builds and new products!
• The best support in the business!

Imagine that – a full range of developer tools across WPF, Silverlight, Windows Phone, Data Access, Web Development and Domain Modeling for just $699!

So, save thousands of dollars by getting all your tools at once with our 30% off Mega Pack Special now.

Hurry, promotion ends 1 Feb 2012!

User interaction

First lets have a look at what this dashboard provides in the user interface. Along the top of the dashboard is the time explorer control. This allows the user to select a time range by dragging or clicking the mouse. By zooming in with the mouse wheel, the time explorer will display shorter time intervals such as weeks and days. Within the time explorer is a line chart displaying some summary data for the overall dashboard. This makes it easy for the user to select a time range around any interesting points in the data. Every time the user selects a new time range, the data displayed in the charts, gauges and data grid are updated to only include the data in the selected time range.

Data drill down

The stacked bar chart below the time explorer is plotting a category breakdown of the data for each point displayed on the X axis. An individual bar shows the data for either a month, day, or 2 hour time slot based on the magnitude of the selected time range. Clicking on one of the bars will drill down to the next time interval.

Category filtering

Selecting one of the segments in the doughnut chart will filter the data grid by the selected category, and emphasise the appropriate points in the stacked bar chart and the equivalent gauge.

Along the bottom of the dashboard is a text block displaying the total sales value, animated linear gauges, and our WPF data grid. Users can reorder, resize and sort the columns in the data grid to display the current data however they would prefer.

MVVM architecture

The MVVM design pattern is commonly used to create robust WPF applications that are easy to maintain. The main idea behind this pattern is to cleanly separate the data model from the user interface. The only things linking these two parts together should be bindings, commands and event handlers. The data model of the dashboard application listens to changes made to the various controls based on the user interaction. These changes are analysed and the displayed data held within the model is updated to reflect the selected time ranges or filters. The controls within the user interface listen to the changes made to the data model and then updates the visuals for the user to see.

You can download the trial version of the latest nightly build from here, or go to your account page if you are already a customer. The smaller data model classes can be found in the Model folder. The main data model class is called DashboardViewModel, and the UI is built up in the DashboardView.xaml file. The SimpleLinearGauge extends our AnimatedValueDisplay, and the remaining class files are for hooking into the Caliburn Micro framework.

Have any questions about WPF Elements? We’d love to hear from you in the forum!

Building on the example we’re created in the first two posts (part 1, part 2), let’s next add a custom cell template to display the numeric data in the Balance column in a currency format. This can be accomplished by setting the DisplayTemplate property of the appropriate DataGridColumn. WPF Elements 5 includes many useful controls for data display and editing, and the CurrencyTextBox is perfect for our purposes. It will format the value with currency information appropriate to the current culture automatically, as well as taking care of the decimal point and cents entered (if any). The CurrencyTextBox control Add this as a Resource:

<!-- style information to make it look how we want -->
<Style x:Key="NegativeBalanceStyle" TargetType="TextBox">
  <Setter Property="Background" Value="Transparent" />
  <Setter Property="Foreground" Value="DarkRed" />
  <Setter Property="BorderThickness" Value="0" />
</Style>
 
<!-- add the currency text box to our data template -->
<DataTemplate x:Key="BalanceCellTemplate">
  <ms:CurrencyTextBox Value="{Binding Balance}" NegativeStyle="{StaticResource NegativeBalanceStyle}"
                      Background="Transparent" Foreground="White" />
</DataTemplate>

and assigning it to the property:

<ms:DataGridColumn PropertyName="Balance" Width="140"
  DisplayTemplate="{StaticResource BalanceCellTemplate}"/>

will format the Balance column nicely.

Next up is custom cell editors. You can be as creative as you like here – if you have a particular type of data that would be especially intuitive to select in a visual manner, or if a custom converter would assist your users, the WPF Data Grid will support it. There are some great examples in the Sample Explorer demos, such as a metric to imperial (feet + inches) converter, and of course the built-in color pickers. You could even allow users to select a timezone graphically like in the DropDownEditBox demo, right in the middle of a Data Grid cell. All these demos are available in the 60 day trial of WPF Elements 5 which you can grab here.

For the phone number column it would be nice to provide the user with a masked textbox to help them enter the required digits. Again WPF Elements 5 comes with a control with this functionality built-in – the Masked Textbox. To apply this control to our Phone column create these resource:

<DataTemplate x:Key="PhoneEditor">
  <ms:MaskedTextBox Mask="00-000-0000" AutoSkipLiterals="True" Text="{Binding Phone}"
                    LiteralStyle="{StaticResource Literal}" PromptStyle="{StaticResource Prompt}" Background="Transparent"
                    PromptCharDisplaySelector="{StaticResource PromptCharDisplaySelector}" />
</DataTemplate>
<Style x:Key="Literal" TargetType="Inline">
  <Setter Property="FontWeight" Value="Bold" />
  <Setter Property="Foreground" Value="DarkGoldenrod" />
</Style>
<Style x:Key="Prompt" TargetType="Run">
  <Setter Property="Foreground" Value="LightGray" />
  <Setter Property="FontFamily" Value="Wingdings" />
</Style>      
<local:FancyPromptCharDisplaySelector x:Key="PromptCharDisplaySelector" />

and then set the property:

<ms:DataGridColumn PropertyName="Phone" Width="120" EditorTemplate="{StaticResource PhoneEditor}" />

This highlights the rather ugly case where the user only partially completes the phone number field, or deletes it altogether. The obvious next step is validation! Fortunately this is also easy to apply to the Data Grid. It provides an event, ValidateCell, which will be raised upon data being altered. Generate the method and inside it place something like this:

object value = e.Cell.Value;
switch (e.Cell.Column.PropertyName)
{
  case "Phone":
    string number = value as string;
    if (number.Length != 11)
    {
      e.IsValid = false;
      e.ValidationMessage = "Number must contain 9 numerals";
    }
    break;
  case "Address":
    string address = value as string;
    if (address.Length == 0)
    {
      e.IsValid = false;
      e.ValidationMessage = "Address cannot be null";
    }
    break;
}

This will produce the behavior illustrated in the screenshot below. The user is prompted for the expected input when editing a cell in the Phone column, and if any invalid input is received the cell will be highlighted with a red border. Much better!

If you haven’t already, download the 60 day trial of WPF Elements 5 to check out the Data Grid and more than 50 other controls.

Rows & Columns

• ShowColumnHeaders- will hide the row of column labels if False. Defaults to True
• ShowRowHeaders- as above
• AllowColumnReorder – allows the user to change the order of columns by dragging and dropping
• RowHeaderWidth – sets the width of the row header block
• AutoGenerateColumns – will create the columns based on the properties in the bound collection

Frozen Columns

• FrozenColumnCount – the specified number of columns will remain stationary when the Data Grid is scrolled horizontally
• ShowFirstFrozenLine – if True if frozen column shadow line will be displayed on the left when FrozenColumnCount is set to 0

Selection & Editing

• HighlightedCell – gets or sets the cell that has focus (black border)
• SelectedCell & SelectedCells – gets or sets the cell, or collection of cells that have been selected (yellow highlight). Both highlighted and selected cells can be set programmatically
• SelectionType – sets a user’s click to highlight either a Row or Cell
• SelectionMode – Single allows one cell/row to be selected at a time; Multiple adds a single cell/row to the current selection with a click; Extended allows a block of cells/rows to be highlighted through click and drag functionality
• AllowEditing – if set to True the user will be able to double-click a cell to edit its contents (if False the Data Grid is read-only). Once in editing mode the user can tab across the row
• SetAllowEditing() – when called on a DataGrid, can set either a cell or a row to be read-only. Can be passed a row or a DataGridCell

Paging

• IsPagerVisible – shows the pager control if is True (defaults to False)
• PageSize – sets number of items on a page. Default is 0 (all items on one page)
• PageIndex – sets the current page to be displayed
• PagerStyle – allows you to set a custom style for the pager control
• MaxPagerButtonCount – sets the maximum amount of page buttons to display (including the ellipsis)
• EllipsisMode – place an ellipsis button (indicating further pages) at positions After, Before, None or Both

For example the following code:

<ms:DataGrid Name="DataGrid" ItemsSource="{Binding Data}" RowHeaderWidth="15" SelectionMode="Extended"
                 SelectionType="Cell" IsPagerVisible="True" PageSize="16" EllipsisMode="Both" MaxPagerButtonCount="5" 
                 AllowColumnReorder="False" FrozenColumnCount="1" >

produces this result:

There is also a whole set of properties for the columns themselves. Naturally you can set Widths & MinWidths, alongside setting the Header (which can be any object, just like a cell). Other properties include AllowSort, AllowResize, AllowEditing, SortDirection and most importantly the DisplayTemplate and EditorTemplate properties, for completely customizing the look and feel of a particular column.

Next time we’ll look at styling the DataGrid, then adding in a custom editor. Download the 60 day trial of WPF Elements now to explore this control plus dozens more. Until next time!