Visual Basic 2010

WPF: How To Move Controls and Elements At Runtime

Ged Mead — Tue, 27 Oct 2009 12:23:00 GMT

XAML is brilliant for creating user interfaces at design time, but if you need to make changes dynamically at runtime, this can sometimes be a problem. To take an example, let's say that you need to allow an Image to move to a different location on screen in response to some user action.

To demonstrate this, we can use an Image which is housed in a Canvas. So the first step is to create a Canvas in a WPF Window, place the Image inside the Canvas and assign a value to the Source property of the Image:

<Window x:Class="Window2"
   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
   Title="Image In A Canvas" Height="300" Width="300">
  <Canvas x:Name="MainCanvas">
    <Image x:Name="MoveableImage" Width="55" Source="questionmark2.jpg" />
  </Canvas>
</Window>

We can then have the Image move a few units to the right each time it receives a mouse click. The WPF Image doesn't support the Click event, but MouseDown is available for the same purpose. So the next step is to wire up an event handler for this:

    <Image x:Name="MoveableImage" Width="55" Source="questionmark2.jpg"
        MouseDown="Image_MouseDown" />

Here's the first pass at the Image_MouseDown event in the code-behind to move the Image 10 units to the right on each mouse down:

    Private Sub Image_MouseDown(ByVal sender As System.Object, ByVal e As System.Windows.Input.MouseButtonEventArgs)
        Dim LeftPos As Double = MoveableImage.GetValue(Canvas.LeftProperty)
 
        MoveableImage.SetValue(Canvas.LeftProperty, LeftPos + 10)
 
    End Sub

This seems straightforward enough, doesn't it? The variable named LeftPos reads the value that is currently stored as the attached Canvas.Left property of the Image, then it increments that value by 10. If you were to run this project, you would expect that the Image would jump 10 units to the right when the mouse is clicked on it. But if you try this code, you will find that nothing happens when the Image is clicked.

There's a little WPF Gotcha lurking in the canvas, just waiting to confuse you. When you create this layout, as you can see from the screenshot below, the Image appears in the top left hand corner of the Canvas by default:

You would be forgiven for assuming that the attached Canvas.Left and Canvas.Top values of the Image are set to zero. It's a reasonable assumption to make, especially as you can see the Image in exactly that location. However, it doesn't actually work like that. By default the Left and Top attached properties are in fact set to Double.NaN - Not A Number. This is effectively a null value that is assigned in order to allow the Canvas to make use of its own built-in layout intelligence for more complex scenarios.

The fix is simple - you just have to assign values to the Canvas.Left and Canvas.Top properties in the XAML when you create the Image element, but it's something that isn't obvious. Not only does it mean that the expected movement of the Image doesn't happen, but it will actually cause your application to crash if you try and reset the value in code to move the Image back to the start position (which we will do later).

So, here's the amended XAML for the Image:

    <Image x:Name="MoveableImage" Width="55" Source="questionmark2.jpg"
        MouseDown="Image_MouseDown" 
        Canvas.Left="0" Canvas.Top="0" /> 

With that change in place, the Image will now move when it is clicked.

In this kind of situation, you probably won't want the Image to either get stuck at the right hand side of the Canvas or, possibly even worse, move out of sight. A simple If/Then statement will fix this:

        If LeftPos < (MainCanvas.ActualWidth - MoveableImage.Width) Then
            MoveableImage.SetValue(Canvas.LeftProperty, LeftPos + 10)
        Else
            MoveableImage.SetValue(Canvas.LeftProperty, CDbl(0))
        End If 

As you can see, the first line tests if there is still enough width remaining for the Image to be moved 10 elements to the right and still be visible. If there is, then the 10 unit jump takes place. If not, then the Image is shunted back to far left of the Canvas. Note that this will fail if you haven't set the initial value of the Canvas.Left property as described earlier.

It will also fail if you don't cast the value (in this example, zero) to a Double. This is because the second parameter of the SetValue method is a generic Object Type and the Canvas.Left property requires a Double.

Moving the Image downwards follows the same kind of logic. You set an initial value on the Canvas.Top property then increment this when the MouseDown event fires. Perhaps you want to build in a feature where the left mouse button causes the Image to move left and the right mouse button to move it down.

If you are moving from Windows Forms to WPF, you may expect to find the Button property of the MouseEventArgs. You would then use code along the lines of:

        If e.Button = Windows.Forms.MouseButtons.Left Then
            ' Do Something
        End If

WPF is (again) slightly different. It uses the System.Windows.Input.MouseButtonEventArgs class in place of the Windows Forms version and it has a ChangedButton property, not a Button property. So the WPF version of the previous snippet will start with:

 If e.ChangedButton = MouseButton.Left Then 

The following code snippet combines the use of either the left or right mouse button to move the Image left or down respectively:

    Private Sub Image_MouseDown(ByVal sender As System.Object, ByVal e As System.Windows.Input.MouseButtonEventArgs)
 
        If e.ChangedButton = MouseButton.Left Then
 
            Dim LeftPos As Double = MoveableImage.GetValue(Canvas.LeftProperty)
 
            If LeftPos < (MainCanvas.ActualWidth - MoveableImage.Width) Then
                MoveableImage.SetValue(Canvas.LeftProperty, LeftPos + 10)
            Else
                MoveableImage.SetValue(Canvas.LeftProperty, CDbl(0))
            End If
 
 
        ElseIf e.ChangedButton = MouseButton.Right Then
            Dim TopPos As Double = MoveableImage.GetValue(Canvas.TopProperty)
 
            If TopPos < (MainCanvas.ActualHeight - MoveableImage.Width) Then
                MoveableImage.SetValue(Canvas.TopProperty, TopPos + 10)
            Else
                MoveableImage.SetValue(Canvas.TopProperty, CDbl(0))
            End If
        End If
 
    End Sub

Finally, of course, you can combine the horizontal and vertical movement of the Image - maybe by using the Middle mouse button:

        ElseIf e.ChangedButton = MouseButton.Middle Then
            MoveableImage.SetValue(Canvas.LeftProperty, MoveableImage.GetValue(Canvas.LeftProperty) + 10)
            MoveableImage.SetValue(Canvas.TopProperty, MoveableImage.GetValue(Canvas.TopProperty) + 10)
        End If

The above snippet can be expanded to have the tests for reaching the outer edges built in also.

The main issues I particularly wanted to cover in this blog item were the GetValue and SetValue methods, which are a very useful tool in these kind of situations. I also wanted to flag up the various WPF Gotchas that might trip up the unwary WinForms developer. In a follow-up blog, I plan to take this task a step further and look at ways of giving the user several ways of achieving the Image movement - all of which loop back to a single piece of code

Populating a WinForms ListView from a Text File

Ged Mead — Mon, 26 Oct 2009 12:41:00 GMT

The Windows Forms ListView is designed to display data. You can use a simple text file as the data source of a Windows Forms ListView. Let's start with a scenario where you have a txt file that contains the data. Each line of the text file represents one row of data to be displayed in the ListView. The content for each column item (or cell) is delimited by the use of a TAB character.

A simple text file along these lines might contain the following entries:

Ged Mead UK
Serge Baranovsky USA
Larry Blake USA
Scott Waletzko USA
Mark Dryden UK
Dave Jeavons UK
Chris Manning USA

(The uneven layout is caused by the use of the TAB as the delimiter)

Reading data from a file
An easy way of transferring this data from the file to the ListView is to:

Use a StreamReader which accesses the text file and then reads it line by line.
As each new line is read, it is split by means of the TAB character and temporarily stored in a String array.
Next, the first element is pulled out of the String array and used as the item for the first column of the ListView (the ListViewItem).
Then the remaining two elements are pulled out of the String array in turn and assigned as the SubItems of the ListViewItem.

Here's the code that carries out those steps:

  ' Variable for file to hold data
    Dim TextFile As String = "F:\MVPs.txt"
 
    Private Sub btnGet_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnGet.Click
 
        Try
            ' Declare StreamReader and pass the Path of the text file to be read as a Parameter 
            Dim SR As New StreamReader(TextFile)
            '  Variable to hold data as it is read line by line
            Dim strTemp() As String
 
            Do While SR.Peek <> -1 ' Use Peek to read the file until there are no more lines 
                '  Create a variable for the ListViewItems
                Dim LVItem As New ListViewItem
                '  Read the next line in file and Split it using the TAB. 
                strTemp = SR.ReadLine.Split(Chr(9))
                '  Pull out the first element in the line and assign it as
                '  the data for the first column.
                LVItem.Text = strTemp(0).ToString
                '  Add the item to the ListView
                LVMVPs.Items.Add(LVItem)
                '  Assign elements 2 & 3 as the subitems.
                LVItem.SubItems.Add(strTemp(1).ToString)
                LVItem.SubItems.Add(strTemp(2).ToString)
            Loop
 
            SR.Close() ' Close the StreamReader 
 
        Catch ex As Exception
 
            MsgBox("Error reading file." & ex.Message)
 
        End Try
 
    End Sub

You'll see that I've used a variable to hold the path to the file that contains the data. You will also need to include an Imports statement for System.IO at the top of the Class file.

Although the above code will successfully access the file, read and split the data and then populate the ListView, the result you will see may not be what you expect or want:

The first problem is that the View Property of the ListView needs to be set to Details. By default it is set to LargeIcon, with the result you see in the screenshot. You can make this change via the Properties Window or in code.

        LVMVPs.View = View.Details 

Make that change, run the project, hit the 'Get From File' button and you will see:

Again, definitely not what you want! The problem here is that the ListView won't automatically create columns for you, even though you might expect that it would based on the data you are feeding in. As it is traditional to have some header text at the top of each column, you can create this at the same time as you create the column itself .

        LVMVPs.Columns.Add("First Name", 76)
        LVMVPs.Columns.Add("Surname", 96)
        LVMVPs.Columns.Add("Location", 56) 

Now, when you run the project again you will see the data neatly tabulated in the ListView.

I have also set the width property of each column in the code above, because the default width would result in some of the longer strings being truncated otherwise.

If you don't want to hard code those column headers, you can change the text file structure and have the column headers written to the first line of the file. You would then pull these out first and assign them to the columns, before using the Do While loop to read and display the rest of the file.

Writing data to a file
Although a ListView's key purpose is to display existing data, there may be times when you have edited the content and want to save it back to a text file. The steps involved in doing this are as follows:

Use a FileStream to set up the file you are going to write to.
Use a StreamWriter to access the chosen file.
Loop through each row of the ListView, pull the text data from each column in turn and write it to the text file, adding a TAB character after each item.
Add a new line at the end of each loop.

The code for this process is:

   Private Sub btnSave_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnSave.Click
        '  Create FileStream and StreamWriter to access and write to file
        Dim FS As New FileStream(TextFile, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite)
        Dim SW As New StreamWriter(FS)
 
        Try
            '  Loop through all rows
            For Index As Integer = 0 To LVMVPs.Items.Count - 1
                '  Internally loop through all columns, gathering items
                For SubIndex As Integer = 0 To LVMVPs.Items(Index).SubItems.Count - 1
                    SW.Write(LVMVPs.Items(Index).SubItems(SubIndex).Text & Chr(9))
                Next
                '  Create new line ready for next row
                SW.Write(Environment.NewLine)
 
            Next
        Catch ex As Exception
 
            MsgBox("Error saving to file." & ex.Message)
 
        Finally
 
            SW.Close()
            FS.Close()
 
        End Try
 
    End Sub

For many simple scenarios where you want to display tabulated text in a ListView (and optionally save it back to a file), the above approaches will work just fine. There will of course be times when you need something more sophisticated and I will look at some of those in later blogs.

How To Sort and Group Items in a WPF ListBox: Part 2

Ged Mead — Sun, 25 Oct 2009 13:26:00 GMT

Introduction
In the first part, I outlined the sample application and said that it:

will create a collection of Person objects and databind them to a ListBox.
will use very simple DataTemplates to format two properties of the Person class - FullName and Status.
will use a GroupStyle HeaderTemplate to display a third property of the Person class - Category.
groups the Person objects by their Category property.
sorts the Categories and displays them in alphabetical order.
sorts the Persons by name inside the Category groups and displays them in alphabetical order.

The first five tasks are all covered in that previous part. You can download the project up to this point from here.

Sorting the Categories
In the same way that I used a Group Description to group items together, WPF offers the SortDescription to allow data inside the CollectionView to be sorted. The following code in the Window Loaded event is all that's needed:

        currentView.SortDescriptions.Add(New SortDescription("Category", ListSortDirection.Ascending))

The SortDescription takes two parameters. The first is the name of the property that you want to sort on. The second is one of two choices for the sort direction.

For completeness, this is the full code so far in the Window Loaded event (which creates the DataContext, the View, the GroupDescription and the SortDescription):

    Private Sub Window1_Loaded(ByVal sender As Object, ByVal e As System.Windows.RoutedEventArgs) Handles Me.Loaded
        Contacts = Person.GetPersons
        Me.DataContext = Contacts
 
        Dim currentView As ICollectionView
        currentView = CollectionViewSource.GetDefaultView(Contacts)
 
        '  Group
        currentView.GroupDescriptions.Add(New PropertyGroupDescription("Category"))
 
        '   Sort Categories
        currentView.SortDescriptions.Add(New SortDescription("Category", ListSortDirection.Ascending))
 
    End Sub

The sorted Categories will look like this:

Sorting the ListItems
As you can see, the Categories are now in alphabetical order. The names of the Person objects however are still shown in the relative order in which they were created. To create this secondary sort, the same kind of code is used:

        currentView.SortDescriptions.Add(New SortDescription("FullName", ListSortDirection.Ascending))

The resulting display is:

The clearest example is where you can see the three items in the 'Work Colleagues' Category. They are now sorted alphabetically.

Note that the order that you list the sorting tasks is important. If you were to reverse the order:

       '   Sort individual names
        currentView.SortDescriptions.Add(New SortDescription("FullName", ListSortDirection.Ascending))
 
        '   Sort Categories
        currentView.SortDescriptions.Add(New SortDescription("Category", ListSortDirection.Ascending))
 

You would effectively lose the Category sort.

It is possible to create and apply the grouping and sorting in XAML, but I always try as far as possible to handle these kind of tasks in code-behind. Equally, I try and use XAML for the actual graphical display. There isn't a clear line between the two sometimes, of course, and you have to allow for individual preferences, but I try and keep to this approach as a general rule.

How To Sort and Group ListItems in a WPF ListBox

Ged Mead — Sun, 25 Oct 2009 13:25:00 GMT

Introduction
I was going to title this blog "What's in a name?" because William Shakespeare's famous question smacked me on the head recently after what seemed like several hours of frustration. The answer in this particular case is "Quite a lot!". As you'll see when I cover the syntax used to group items, you can very easily fall into a trap when it comes to names.

But first, I'll need to set the scene. This small application:

will create a collection of Person objects and databind them to a ListBox.
will use very simple DataTemplates to format two properties of the Person class - FullName and Status.
will use a GroupStyle HeaderTemplate to display a third property of the Person class - Category.
groups the Person objects by their Category property.
sorts the Categories and displays them in alphabetical order.
sorts the Persons by name inside the Category groups and displays them in alphabetical order.

The Person Class
First, the Person Class - which I have chosen to implement INotifyPropertyChanged, although I don't actually take advantage of the change notification in this simple example:

Imports System.ComponentModel
Imports System.Collections.ObjectModel
 
Public Class Person
    Implements INotifyPropertyChanged
 
    Sub New(ByVal personname As String, ByVal personstatus As String, ByVal personsgroup As String)
        Me.FullName = personname
        Me.Status = personstatus
        Me.Category = personsgroup
    End Sub
 
    Private _name As String
    Public Property FullName() As String
        Get
            Return _name
        End Get
        Set(ByVal value As String)
            _name = value
            OnPropertyChanged(New PropertyChangedEventArgs("FullName"))
        End Set
    End Property
 
    Private _status As String
    Public Property Status() As String
        Get
            Return _status
        End Get
        Set(ByVal value As String)
            _status = value
            OnPropertyChanged(New PropertyChangedEventArgs("Status"))
        End Set
    End Property
 
    Private _Category As String
    Public Property Category() As String
        Get
            Return _Category
        End Get
        Set(ByVal value As String)
            _Category = value
            OnPropertyChanged(New PropertyChangedEventArgs("Category"))
        End Set
    End Property
 
    Public Sub OnPropertyChanged(ByVal e As PropertyChangedEventArgs)
        If Not PropertyChangedEvent Is Nothing Then
            RaiseEvent PropertyChanged(Me, e)
        End If
    End Sub 
 
    Public Event PropertyChanged(ByVal sender As Object, ByVal e As System.ComponentModel.PropertyChangedEventArgs) Implements System.ComponentModel.INotifyPropertyChanged.PropertyChanged
 
 
    Public Shared Function GetPersons() As List(Of Person)
        Dim GP As New List(Of Person)
        GP.Add(New Person("Neil Birch", "Available", "My Friends"))
        GP.Add(New Person("Joe Brown", "On Site", "Work Colleagues"))
        GP.Add(New Person("Larry Blake", "Available", "VB City"))
        GP.Add(New Person("Fran Mead", "At Work", "Family"))
        GP.Add(New Person("Elaine Javan", "On Vacation", "Work Colleagues"))
        GP.Add(New Person("Matt Higginbotham", "On Line", "VB City"))
        GP.Add(New Person("Zoe Flint", "On Site", "Work Colleagues"))
        Return GP
    End Function
 
End Class

Essentially, all you need to note for the purpose of this article is that the GetPersons function creates a List (of Person) and each Person instance has values assigned to all three of the properties of the class - FullName, Status, and Category.

The WPF Window
The WPF Application contains just one Window. A List of Persons is created by using the GetPersons function and this List is used as the DataContext for the Window. This will allow the ListBox to access that List. The initial code-behind is as follows:

Class Window1
    Dim Contacts As New List(Of Person)
    Private Sub Window1_Loaded(ByVal sender As Object, ByVal e As System.Windows.RoutedEventArgs) Handles Me.Loaded
        Contacts = Person.GetPersons
        Me.DataContext = Contacts
    End Sub
 
End Class

The ListBox
In the XAML for Window1, there is a ListBox. To begin with, this ListBox simply shows the Person's FullName, followed by their Status. There is a minimal amount of formatting in the two TextBlocks that are used for this.

      <ListBox Name="lstContacts"
        ItemsSource="{Binding}" 
        Margin="6,6,3,3" >
 
 
        <ListBox.ItemTemplate>
        <DataTemplate >
          <StackPanel >
            <TextBlock Text="{Binding Path=FullName}"
              Margin="0,2,0,0"/>
            <TextBlock Text="{Binding Path=Status}" 
              Margin="6,0,0,0" FontSize="11" Foreground="Navy" />
 
          StackPanel>
        DataTemplate>
      ListBox.ItemTemplate>
    ListBox>

The result so far is this:

Obviously, there is no sorting or grouping going on there yet.

CollectionView
When you set up the Binding between the data source (the List of Persons) and the target control (the ListBox), a CollectionView is created automatically. This is a wrapper for the binding and allows you to sort, filter, group or navigate through the collection without affecting the underlying collection itself. Think of it as an editable snapshot of the data and you won't be far off the mark

You can access the current view by using the GetDefaultView method and passing in the name of the data source - in this case, the Contacts List created in the code-behind of Window1. In our example, we will access the CollectionView and then group and sort the items as they are displayed in the ListBox. To try and keep things as straightforward as possible I'll tackle each of these one at a time.

Creation of an instance of the view by means of the GetDefaultView method is simple.

Imports System.ComponentModel

    Private Sub Window1_Loaded(ByVal sender As Object, ByVal e As System.Windows.RoutedEventArgs) Handles Me.Loaded
        Contacts = Person.GetPersons
        Me.DataContext = Contacts
 
        Dim currentView As ICollectionView
        currentView = CollectionViewSource.GetDefaultView(Contacts)
    End Sub
 
End Class

Note the inclusion of the Imports statement for System.ComponentModel, the class which houses ICollectionView.

It's the final two lines of the Window_Loaded event that create the View:

Grouping

The following line of code, placed in the Window_Loaded event, will group the individual items based on the Category property:

        currentView.GroupDescriptions.Add(New PropertyGroupDescription("Category"))

The result is shown below:

So I don't have to be much of a mind reader to know that you're not too impressed at this point. In fact, you probably don't even believe that the items are now grouped. And even if they are, it's not very obvious to the user.

Let's start with the question of whether they are really grouped. If you look carefully at the order of the names you will see that they have changed from the way they were originally listed - as seen in the earlier screenshot. And if you take a peek at the code which created the Person instances you will be able to see the value of the Category property for each instance.

    Public Shared Function GetPersons() As List(Of Person)
        Dim GP As New List(Of Person)
        GP.Add(New Person("Neil Birch", "Available", "My Friends"))
        GP.Add(New Person("Joe Brown", "On Site", "Work Colleagues"))
        GP.Add(New Person("Larry Blake", "Available", "VB City"))
        GP.Add(New Person("Fran Mead", "At Work", "Family"))
        GP.Add(New Person("Elaine Javan", "On Vacation", "Work Colleagues"))
        GP.Add(New Person("Matt Higginbotham", "On Line", "VB City"))
        GP.Add(New Person("Zoe Flint", "On Site", "Work Colleagues"))
        Return GP
    End Function

Now, you can see that the first Category is "My Friends" and Neil Birch is the sole member of that Category. More usefully, the next three instances - Joe Brown, Elaine Javan and Zoe Flint all have "Work Colleagues" as their Category. They are now all listed consecutively - and both Elaine Javan and Zoe Flint have been moved from their original positions.

The next two names - Larry Blake and Matt Higginbotham are both in the "VB City" Category. Fran Mead is the sole member of the "Family" Category.

So, the grouping has actually taken place. The order of the Categories is based on the order in which they first appear in the GetPersons function.

Clearly, we need something to make the grouping of Categories more obvious. And that 'something' is a GroupStyle. GroupStyle has a HeaderTemplate property which can be used to format the text and/or graphics that are displayed at the start of each group - in this case at the start of each Category.

The XAML is a little bit verbose, but - apart from one potential Gotcha - is straightforward.

      <ListBox.GroupStyle>
        <GroupStyle>
          <GroupStyle.HeaderTemplate>
            <DataTemplate>
              <TextBlock Text="{Binding Path=Name}" FontWeight="Bold"/>
            DataTemplate>
          GroupStyle.HeaderTemplate>
        GroupStyle>
      ListBox.GroupStyle>

The GroupStyle has a HeaderTemplate. The HeaderTemplate contains a DataTemplate. In this case I have chosen to include only a basic TextBlock in the DataTemplate. The Text property of the TextBlock needs to show the Category name.

This is where I managed to get myself quite confused.

  <TextBlock Text="{Binding Path=Name}" FontWeight="Bold"/>

I initially had a property in the Person class called Name. (I've since changed it to FullName for clarity.) I couldn't understand why the Path of a TextBlock that showed the Category value would be pointing to the Name property of Person class. And of course it doesn't. But, while I was getting to grips with this I set the path to what I thought was the most logical item - the Category property. In other words, I had it like this:

 <TextBlock Text="{Binding Path=Category}" FontWeight="Bold"/>

Now, WPF is so forgiving when it comes to this kind of data binding that it doesn't throw an exception (quite rightly, because it is a valid path to an existing field). Sadly it doesn't show the Categories either. The result at this point is:

You can see that they are grouped, but there's no header. The key lesson to take away from this is that the Path in that particular binding points to the name that is assigned to the PropertyGroupDescription in the code-behind:

   currentView.GroupDescriptions.Add(New PropertyGroupDescription("Category"))

Confused yet? Put simply, you always use the syntax of:

              <TextBlock Text="{Binding Path=Name}" FontWeight="Bold"/>

regardless of what the actual name of the grouping property is. You're probably thinking that we're well into the "Too much information" stage now, but - apart from wanting to share my pain - I really think that this is Gotcha that is just waiting to bite the unwary and so it was worth spending a couple of extra minutes looking at it.

OK, so getting back on track, the correct version of the GroupStyle markup will bring you the result you want. I have included all the ListBox XAML so you can see the finished product:

   <ListBox Name="lstContacts"
        ItemsSource="{Binding}" 
        Margin="6,6,3,3" >
 
      <ListBox.GroupStyle>
        <GroupStyle>
          <GroupStyle.HeaderTemplate>
            <DataTemplate>
              <TextBlock Text="{Binding Path=Name}" FontWeight="Bold"/>
            DataTemplate>
          GroupStyle.HeaderTemplate>
        GroupStyle>
      ListBox.GroupStyle>
 
      <ListBox.ItemTemplate>
        <DataTemplate >
          <StackPanel >
            <TextBlock Text="{Binding Path=FullName}"
              Margin="0,2,0,0"/>
            <TextBlock Text="{Binding Path=Status}" 
              Margin="6,0,0,0" FontSize="11" Foreground="Navy" />
 
          StackPanel>
        DataTemplate>
      ListBox.ItemTemplate>
    ListBox>

Here it is:

The grouping is clear, has a useful header and - more to the point - is accurate. The Categories are not yet in alphabetical order. The individual Person instances are also not sorted within their Categories, as you can see from the order in the Work Colleagues group.

As this blog has become a bit longer than I expected, I will continue with a Part 2, which will cover the Sorting methods.

I have posted a copy of this project which you can download from here.

WPF ValueConverter Using Enumeration and Image Paths

Ged Mead — Sun, 25 Oct 2009 13:22:00 GMT

In the previous blogs on ValueConverters - here and here - the conversion was from Integer type to Brush. In this blog I will cover the situation where you want to include a small image or icon in the ListView.

There are various alternatives here. You could hard code the image path into the collection, but the problem may be that you don't know the exact image paths at the time the collection is created. The approach I want to use is where you parse the data as it feeds through the binding and you select a stored image from the hard drive, the selection being based on the value of a specific field. This decouples the details of the image from the collection itself, which may be useful in many situations.

The DrinkProduct class looks like this:

Public Class DrinkProduct
    Enum MaterialType
        Granules
        Leaf
        Liquid
        Paste
        Powder
        Other
    End Enum
    Sub New(ByVal ID As String, ByVal Name As String, ByVal PackType As String, _
           ByVal BaseMaterial As MaterialType, ByVal Sales As Integer, ByVal Qty As Integer)
        Me.ProductID = ID
        Me.ProductName = Name
        Me.PackageType = PackType
        Me.Material = BaseMaterial
        Me.AnnualSales = Sales
        Me.Quantity = Qty
    End Sub
 
    Private _ProductID As String
    Public Property ProductID() As String
        Get
            Return _ProductID
        End Get
        Set(ByVal value As String)
            _ProductID = value
        End Set
    End Property
 
    Private _ProductName As String
    Public Property ProductName() As String
        Get
            Return _ProductName
        End Get
        Set(ByVal value As String)
            _ProductName = value
        End Set
    End Property
 
    Private _PackageType As String
    Public Property PackageType() As String
        Get
            Return _PackageType
        End Get
        Set(ByVal value As String)
            _PackageType = value
        End Set
    End Property
 
 
    Private _Material As MaterialType
    Public Property Material() As MaterialType
        Get
            Return _Material
        End Get
        Set(ByVal value As MaterialType)
            _Material = value
        End Set
    End Property
 
    Private _quantity As Integer
    Public Property Quantity() As Integer
        Get
            Return _quantity
        End Get
        Set(ByVal value As Integer)
            _quantity = value
        End Set
    End Property
 
 
    Private _annualsales As Integer
    Public Property AnnualSales() As Integer
        Get
            Return _annualsales
        End Get
        Set(ByVal value As Integer)
            _annualsales = value
        End Set
    End Property
 
    Public Shared Function StockCheck() As List(Of DrinkProduct)
        Dim CurrentProducts As New List(Of DrinkProduct)
        With CurrentProducts
            .Add(New DrinkProduct("CF1kg", "Coffee Powder", "1 Kg", MaterialType.Powder, 15684, 1276))
            .Add(New DrinkProduct("CFB500", "Ground Coffee", "500 g", MaterialType.Powder, 22785, 12856))
            .Add(New DrinkProduct("CFG500", "Coffee Granules", "500 g", MaterialType.Granules, 19233, 5907))
            .Add(New DrinkProduct("Te500", "Tea", "500 g", MaterialType.Leaf, 8544, 235))
            .Add(New DrinkProduct("TeInst500", "Instant Tea", "500 g", MaterialType.Powder, 1009, 22))
            .Add(New DrinkProduct("SMlk1lt", "Skimmed Milk", "1 Litre", MaterialType.Liquid, 28012, 2650))
            .Add(New DrinkProduct("HiJ300", "HiJuice Drink Mix", "300 g", MaterialType.Other, 578, 179))
            .Add(New DrinkProduct("Sm400", "Smoothie", "400ml", MaterialType.Paste, 9346, 3284))
            .Add(New DrinkProduct("Beef300", "Beef Drink", "300 g", MaterialType.Granules, 8316, 1965))
            .Add(New DrinkProduct("Beef750", "Beef Drink", "750 g", MaterialType.Granules, 7612, 359))
 
        End With
 
        Return CurrentProducts
    End Function
 
End Class 

The Enumeration named 'MaterialType' identifies whether the product is powder, liquid, granule, etc and this is what I will use as the key for selecting the appropriate image.

The ValueConverter class is similar to those used in the previous blogs - IValueConverter requires the two methods named Convert and ConvertBack. ConvertBack serves no purpose is this scenario, so only throws a not implemented exception.

Public Class MaterialToImagePathConverter
    Implements IValueConverter
 
    Public Function Convert(ByVal value As Object, ByVal targetType As System.Type, ByVal parameter As Object, ByVal culture As System.Globalization.CultureInfo) As Object Implements System.Windows.Data.IValueConverter.Convert
        Select Case value.ToString
            Case "Powder"
                Return "Images/powderbrown.jpg"
            Case "Liquid"
                Return "Images/liquiddrop4.jpg"
            Case "Leaf"
                Return "Images/leaf.jpg"
            Case "Granules"
                Return "Images/granules.jpg"
            Case "Paste"
                Return "Images/Paste2.jpg"
            Case Else
                Return "Images/questionmark.jpg"
        End Select
 
    End Function
 
    Public Function ConvertBack(ByVal value As Object, ByVal targetType As System.Type, ByVal parameter As Object, ByVal culture As System.Globalization.CultureInfo) As Object Implements System.Windows.Data.IValueConverter.ConvertBack
        Throw New NotImplementedException()
    End Function
End Class 

As before, the parameter named 'value' is an Object type which is the key element in the conversion process. It contains the value that is to be converted. The conversion is simple in this case because all we need is to find the string value of the enumeration that is being passed in. So the basic ToString method will work fine.

Once we have a String value, this is compared against the various possibilities. A string which represents the file path to an appropriate image is returned by the converter. I've chosen to include the image files in the project, but of course they could be stored externally and still be accessed in the same way.

The next steps are the same as for the previous examples in the earlier blogs. First, map the current assembly to an XML namespace in Application.xaml:

  xmlns:local="clr-namespace:WPFListView2"  

Then create an instance of the converter class in Application.xaml and give it a key:

    <local:MaterialToImagePathConverter x:Key="IconConverter" /> 

Next, create a DataTemplate for the new column of the ListView:

    <DataTemplate x:Key="IconCellTemplate">
            <Image Margin="0,0,1,3" Height="18" Width="25"
          Stretch="Fill"      
        Source="{Binding Path=Material, Converter={StaticResource IconConverter}}" />
    DataTemplate> 

In the above markup, the Binding Path is the Material field, the converter is the MaterialToImagePathConverter instance created above.

Finally, the ListView in the Window needs to have a new column added in which the images can be displayed:

          <GridViewColumn
           CellTemplate="{StaticResource IconCellTemplate}">
          GridViewColumn> 

And now you are all set. The finished Window displays as shown below:

For completeness, the full markup for the Window which contains the ListView is shown here:

<Window x:Class="Window2"
   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
   Title="Image Path Converter Demo" Height="360" Width="450">
  <Grid>
 
    <ListView Name="ProductsListView"
         ItemsSource="{Binding}"
           Margin="5" >
 
      <ListView.ItemContainerStyle>
        <Style TargetType="ListViewItem">
          <Setter Property="HorizontalContentAlignment" Value="Stretch" />
        Style>
      ListView.ItemContainerStyle>
 
      <ListView.View>
        <GridView>
          
          <GridViewColumn
           CellTemplate="{StaticResource IconCellTemplate}">
          GridViewColumn>
          
          <GridViewColumn 
           HeaderTemplate="{StaticResource IDColHeader}"
          CellTemplate="{StaticResource IDCellTemplate}">
          GridViewColumn>
          
          <GridViewColumn 
           HeaderTemplate="{StaticResource NameColHeader}"
           CellTemplate="{StaticResource NameCellTemplate}">
          GridViewColumn>
          
          <GridViewColumn 
           HeaderTemplate="{StaticResource PackageColHeader}"
           CellTemplate="{StaticResource PackCellTemplate}">
          GridViewColumn>
        GridView>
      ListView.View>
    ListView>
 
  Grid>
Window> 

Of course you are not forced to use the ValueConverter approach for this task. You could rewrite the class and give it an ImagePath property. Then in the code-behind run a function with a similar Select Case block to the one used above, passing back the appropriate path to the ImagePath property. The collection would be amended on the fly to include this data and finally the amended collection would be used as the DataContext. The Binding Path for the Image Source property would be that field. Personally, I think the ValueConverter is neater. And if the data comes from an external source, perhaps in the form of an XML file, then using the ValueConverter is almost certainly a better way.

Using a ValueConverter in WPF

Ged Mead — Sun, 25 Oct 2009 13:20:00 GMT

The Story So Far
Each of my previous blog items on WPF ListViews has mostly used a collection of DrinkProduct objects as the data source. This collection is bound to the Window via a DataContext and the individual columns are bound to fields in the collection. (As an alternative, this blog looked at the XML data source alternative.)

As the route from that first ListView blog to this one has become a bit murky, I'm going to start off by recreating the DrinkProduct class and creating the collection. I've taken the opportunity to add a few new properties which will be used in this and the upcoming ListView blogs.

You can view the revised DrinkProducts class code here.

The XAML markup for the start state of the ListView is in two locations. The ListView itself is in a WPF Window:

<Window x:Class="Window1"
   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
   Title="WPF ListView" Height="300" Width="450">
    <Grid>
    <ListView Name="ProductsListView"
         ItemsSource="{Binding}"
           Margin="5" >
 
      <ListView.View>
        <GridView>
          
          <GridViewColumn 
           HeaderTemplate="{StaticResource IDColHeader}"
          CellTemplate="{StaticResource IDCellTemplate}">
          GridViewColumn>
          
          <GridViewColumn 
           HeaderTemplate="{StaticResource NameColHeader}"
           CellTemplate="{StaticResource NameCellTemplate}">
          GridViewColumn>
          
          <GridViewColumn 
           HeaderTemplate="{StaticResource PackageColHeader}"
           CellTemplate="{StaticResource PackCellTemplate}">
          GridViewColumn>
        GridView>
      ListView.View>
    ListView>
  Grid>
Window> 

All the Resources - GradientBrush, Styles, DataTemplates for ColumnHeaders and Cells - are in the Application.xaml file. You can see the markup for these here.

If the Resources looks like a lot of markup, it breaks down into much less if you analyze it. There's a GradientBrush, a couple of Styles, then the DataTemplates, which are really only slightly tweaked versions of two simple templates.

At this stage the ListView looks like this:

ValueConverters
In this blog I want to demonstrate a simple example of the creation and use of a ValueConverter in WPF. ValueConverters are particularly useful in situations where you are using data binding to directly populate elements in the UI. By definition, this means that the data from the fields of the data source are passed untested from the source to the display.

This data will often be in a raw state, e.g. primitive types such as integer, double, boolean, etc. In the first example I will use integer values that represent the quantity of stock remaining of the various drink products. These will be displayed in a new column of the ListView.

Although the DataTemplates created earlier can alter the core properties of all the values in the column - Foreground, Bold font, etc,- they don't offer any mechanism for analyzing these values and changing the look of the display of an individual value based on some criteria. For instance, changing the color of the text if the value is negative.

The way to achieve this kind of fine tuning is to use a ValueConverter. This automatically intercepts the data as it is being fed in from the DataContext, analyzes the value and makes any appropriate settings or changes to the display of this piece of data.

A Simple ValueConverter
Let's start with something simple, a ValueConverter that analyzes the quantity held in stock and if that value is less than a particular threshold, the figure is displayed in red in the ListView. This will give an easy introduction to the steps involved.

Before getting round to the ValueConverter I need to add a new column to the ListView, the column that will display the quantities held in stock. First a couple of DataTemplates - one for the column header and for the cell:

      
    <DataTemplate x:Key="QtyColHeader">
      <Border Style="{StaticResource BlueBorder}">
        <TextBlock Text="Quantity " Style="{StaticResource ColHeaderText}" />
      Border>
    DataTemplate>
 

      
    <DataTemplate x:Key="QtyCellTemplate">
      <TextBlock Foreground="MediumBlue"
         Text="{Binding Path=Quantity}" />
    DataTemplate> 

Followed by the additional column in the ListView itself:

          
          <GridViewColumn 
           HeaderTemplate="{StaticResource QtyColHeader}"
           CellTemplate="{StaticResource QtyCellTemplate}">
          GridViewColumn> 

With just the raw quantity values showing in the new column, the ListView now looks like this:

For the sake of example, let's say that we want to highlight in red all values that are less than 200. First we create a class that implements IValueConverter. This implementation requires two methods - Convert and ConvertBack - each with a standard signature. Here is the code, which can be placed in a file of its own or - as I have chosen to do - appended to the end of (but not inside!) the Application.xaml.vb file:

Public Class IntegerToBrushConverter
    Implements IValueConverter
 
    Public Function Convert(ByVal value As Object, ByVal targetType As Type, _
        ByVal parameter As Object, ByVal culture As System.Globalization.CultureInfo) _
        As Object Implements IValueConverter.Convert
 
        ' Only allow conversion if the correct TargetType is passed in.
        '  (This is optional)
        If targetType IsNot GetType(Brush) Then
            Return Nothing
        End If
 
        '  If less than 200 in stock, display in Red, otherwise use 
        '  the default of MediumBlue
        Dim Result As Integer = Integer.Parse(value.ToString())
        Return (If(Result < 200, Brushes.Red, Brushes.MediumBlue))
    End Function
 
    Public Function ConvertBack(ByVal value As Object, ByVal targetType As Type, _
ByVal parameter As Object, ByVal culture As System.Globalization.CultureInfo) _
As Object Implements IValueConverter.ConvertBack
 
        ' Not used, so throw exception if this method is called.
        Throw New NotImplementedException()
    End Function
End Class

As you can see from the comments, I have chosen to test that a Brush object is passed in to the method. This isn't mandatory but is often worth including. The second test in the Convert method checks the value of the current field and if it finds the value to be less than 200, Returns a Red Brush, otherwise it Returns a MediumBlue Brush.

Clearly, what is needed next is some mechanism that is watching for those returned values and making use of the particular brush that is returned. This is handled in the markup in the Application.xaml file. If you are wondering why the markup is in Application.xaml and not the Window that contains the ListView, the reason is that we need to set the conversion on the DataTemplate that formats the Quantity column. And that DataTemplate is in Application.xaml.

As things stand, the XAML markup is unable to access the code above directly. So the first requirement is to map the current project into an XML namespace, making it possible to create a direct link between the two. The syntax for this is as follows:

  xmlns:local="clr-namespace:WPFListview" 

which is placed in the Application.xaml file, just below the default XML namespaces which are placed there automatically. This now gives the ability to refer to the IntegerToBrushConverter in the XAML markup. (You may find that you have to Rebuild the solution to remove the wavy blue error mark after you first enter this. )

Now that the mapping is in place, I can create an instance of the IntegerToBrushConverter class and assign it a key so that it can be referred to in the XAML.

  <local:IntegerToBrushConverter x:Key="QtyConverter" /> 

The final step is to use this instance of the converter inside the DataTemplate for the Quantity column. This markup is in the Application.xaml file:

    
    <DataTemplate x:Key="QtyCellTemplate">
      <TextBlock 
         Text="{Binding Path=Quantity}" 
          Foreground="{Binding Path=Quantity, Converter={StaticResource QtyConverter}}"/>
    DataTemplate> 

The only change is to the Foreground property in the markup,which I have changed from the original hard-coded value of MediumBlue to the Binding you can see there. The syntax is reasonably straightforward:

The Path has to be an Integer type because that is what the IntegerToBrushConverter expects.
The relevant Path points to the field that the column is being databound to - Quantity.
The Converter in the Binding refers to that instance of the IntegerToBrushConverter created a few moments ago and given the key of 'QtyConverter'.

The resulting display when the project runs is now:

Just to briefly cover the ConvertBack method, you can see from the commenting that this method isn't of use to us in this scenario. However, IValueConverter requires that it is included, so we simply throw an Exception if this method should be accessed at any point.

This has been a very simple example of using a ValueConverter, but it includes all the key steps. I plan to cover some more complex scenarios in later blogs.

More Complex Conversions with the WPF MultiBinding Converter

Ged Mead — Sun, 25 Oct 2009 13:18:00 GMT

In the previous blog, I created a simple ValueConverter that analyzed the data bound values and set the Foreground color of a TextBlock based on whether the value was less or more than a cut off value of 200 units. In reality, these preset values (such as the 200 in that demonstration) are rarely that rigid and you often need some flexibility in the analysis. To continue the example of a collection of drink products, it might be more realistic to compute a cut off value on the fly. For instance, if you know your annual sales for an individual item and you know the quantity you have in stock, you might want to highlight those items that need to be re-ordered. If it's a big selling item, the value of 200 may be far too low as a cut off; conversely an item with low annual sales might only need to be re-ordered when the stock is down to a handful.

So, how do we include this kind of calculation in a process where the value is data bound, but we need to apply some arithmetic to more than one field? The answer is to use MultiBinding and a MultiValueConverter.

You create a class that implements IMultiValueConverter. The core difference between this class and the one created in the previous blog is that the 'value' parameter of the Convert method is renamed to 'values' and is an array, not a single object. Armed with that array, you can pass in the values of two or more of the fields of your data source, run the calculations and Return a result.

Take a look at this class:

Public Class StockLevelConverter
    Implements IMultiValueConverter
 
    Public Function Convert(ByVal values() As Object, ByVal targetType As System.Type, ByVal parameter As Object, ByVal culture As System.Globalization.CultureInfo) As Object Implements System.Windows.Data.IMultiValueConverter.Convert
 
        If targetType IsNot GetType(Brush) Then Return Nothing
 
        '  Variables for the arithmetic operations
        Dim QtyHeld As Integer = CInt(values(0))
        Dim AnnualSales As Integer = CInt(values(1))
 
        '  Avoid divide by zero errors by not proceeding to the calculation
        '  and returning a different brush 
        If QtyHeld = 0 Or AnnualSales = 0 Then Return Brushes.DarkGray
 
        Dim RestockLevel As Integer = AnnualSales / 12
 
        Return (If(QtyHeld < RestockLevel, Brushes.Red, Brushes.MediumBlue))
 
    End Function
 
    Public Function ConvertBack(ByVal value As Object, ByVal targetTypes() As System.Type, ByVal parameter As Object, ByVal culture As System.Globalization.CultureInfo) As Object() Implements System.Windows.Data.IMultiValueConverter.ConvertBack
        Throw New NotImplementedException()
    End Function
End Class

It is similar to the converter class created in the previous blog, having the same two methods, Convert and ConvertBack. Note that this class implements IMultiValueConverter and the first parameter being an array as mentioned earlier.

In the Convert method, I have included the test that confirms that the correct Target Type has been passed in. Two variables, QtyHeld and AnnualSales are created and you will see that their respective values are taken from the two elements of the array named 'values' passed in as a parameter. We will need to look at how those array elements are notified to the converter in a moment.

Continuing with the Convert method, a test is included to avoid any divide by zero errors. I have chosen to Return a different colored Brush, but it could have been left to the default of MediumBlue if preferred.

The 'RestockLevel' variable could have been left out and the calculation that it uses could have been placed inside the If statement in the final line. But I felt that it is easier to read in the more verbose approach. The gist of these two lines is to divide the annual sales figure by 12 in order to find the average monthly sales. If the Stock held is less than one month's worth, then a Red Brush is returned, otherwise a MediumBlue one.

So, how do the values in the array get passed in to the Convert method? The answer is that a MultiBinding is used in the XAML. This is a similar approach to the single ValueConverter example seen previously, except that this time two Paths are required - one for the Quantity field and one for the AnnualSales field of the data source.

Assuming you are using the same project as in the previous blog, there is already a namespace mapping named 'local'. You then need to create an instance of this new converter class:

    <local:StockLevelConverter x:Key="StockChecker" />

The DataTemplate for the Quantity column cells will contain the MultiBinding. Here is the markup for this:

    <DataTemplate x:Key="QtyCellTemplate">
      <TextBlock 
          Text="{Binding Path=Quantity}" >
        <TextBlock.Foreground>
          <MultiBinding Converter="{StaticResource StockChecker}">
            <Binding Path="Quantity" />
            <Binding Path="AnnualSales" />
          MultiBinding>
        TextBlock.Foreground>
      TextBlock>
    DataTemplate> 

The Element.Property syntax is used to allow for the multiple sub elements. The MultiBinding is created and set to point to that instance of the StockLevelConverter class, which has been keyed as 'StockChecker'. The two paths which are passed in to the StockLevelConverter are listed next. Note that the array is filled in the order in which these paths are listed - that is values(0) will take the Quantity field values and values(1) will take the AnnualSales field values.

That's all there is to it. If I create some arbitrary dummy data for all the properties of the DrinkProduct class collection (i.e. including the Quantity and AnnualSales figures) and run the project, the resulting ListView will look like this:

If you're interested in trying this out, using the class code from the previous blog but can't be bothered to create your own dummy data, here is the collection I created:

  Public Shared Function StockCheck() As List(Of DrinkProduct)
        Dim CurrentProducts As New List(Of DrinkProduct)
        With CurrentProducts
            .Add(New DrinkProduct("CF1kg", "Coffee Powder", "1 Kg", MaterialType.Powder, 15684, 1276))
            .Add(New DrinkProduct("CFB500", "Ground Coffee", "500 g", MaterialType.Powder, 22785, 12856))
            .Add(New DrinkProduct("CFG500", "Coffee Granules", "500 g", MaterialType.Granules, 19233, 5907))
            .Add(New DrinkProduct("Te500", "Tea", "500 g", MaterialType.Leaf, 8544, 235))
            .Add(New DrinkProduct("TeInst500", "Instant Tea", "500 g", MaterialType.Powder, 1009, 22))
            .Add(New DrinkProduct("SMlk1lt", "Skimmed Milk", "1 Litre", MaterialType.Liquid, 28012, 2650))
            .Add(New DrinkProduct("HiJ300", "HiJuice Drink Mix", "300 g", MaterialType.Other, 578, 179))
            .Add(New DrinkProduct("Sm400", "Smoothie", "400ml", MaterialType.Paste, 9346, 3284))
            .Add(New DrinkProduct("Beef300", "Beef Drink", "300 g", MaterialType.Granules, 8316, 1965))
            .Add(New DrinkProduct("Beef750", "Beef Drink", "750 g", MaterialType.Granules, 7612, 359))
 
        End With
 
        Return CurrentProducts
    End Function

Don't forget to include the DataContext in the code-behind of Window1, the Window that holds the actual ListView:

Class Window1 
    Dim CurrentProducts As New List(Of DrinkProduct)
 
 
    Private Sub Me_Loaded(ByVal sender As Object, ByVal e As System.Windows.RoutedEventArgs) Handles Me.Loaded
        CurrentProducts = DrinkProduct.StockCheck()
        Me.DataContext = CurrentProducts
    End Sub
End Class

WPF ListView - How To Format the Appearance of Rows

Ged Mead — Sun, 25 Oct 2009 13:17:00 GMT

By the end of the previous blog item on the topic of the WPF ListView, the ListView looked like this:

In this blog I want to look at ways of changing the look of the rows. You may, for example, want to assign a background color to the rows. And based on what we have done so far, you might be tempted to edit the DataTemplates used for the cells. Maybe you would think about adding a Border with a Background fill and placing this around the TextBlock for each cell:

  <DataTemplate x:Key="IDCellTemplate2">
      <Border Background="LightGreen"> 
      <TextBlock Foreground="MediumBlue"
                FontFamily="Calibri"
         Text="{Binding Path=ProductID}" />
      Border>
    DataTemplate> 

I won't waste the space showing the markup for all three templates here, but if you did try this you will get a disappointing result:

Pretty ugly, I think you'll agree. Playing around with the Margin or Padding won't get you any further either.

The answer is to use the ItemContainerStyle property of the ListView. This opens up a number of choices for you. Firstly, if you would like to still have a gap between each of the columns - but an even gap - then you can take the following approach:

      <ListView.ItemContainerStyle>
        <Style TargetType="ListViewItem">
          <Setter Property="HorizontalContentAlignment" Value="Stretch" />
        Style>
      ListView.ItemContainerStyle> 

This will produce the following output, which is an improvement:

If you want the light green to spread across the whole row, then you still use the ItemContainerStyle, but this time you set the Background property of the ListViewItem:

      <ListView.ItemContainerStyle>
        <Style TargetType="ListViewItem">
            <Setter Property="Background" Value="LightGreen" />
        Style>
      ListView.ItemContainerStyle> 

Now you get the result you are probably looking for.

If all that whiteness in the background is a bit too much for you, then of course you can blend another shade of green into the mix by setting the ListView's Background property. Using SeaGreen, for example, will produce this:

The final markup for the ListView looks like this:

    <ListView Name="ProductsListView"
         ItemsSource="{Binding}"
           Margin="5,25" 
              Background="SeaGreen">
      <ListView.ItemContainerStyle>
        <Style TargetType="ListViewItem">
            <Setter Property="Background" Value="LightGreen" />
        Style>
      ListView.ItemContainerStyle>
 
      <ListView.View>
        <GridView>
          
          <GridViewColumn 
           HeaderTemplate="{StaticResource IDColHeader}"
          CellTemplate="{StaticResource IDCellTemplate}">
          GridViewColumn>
          
          <GridViewColumn 
           HeaderTemplate="{StaticResource NameColHeader}"
           CellTemplate="{StaticResource NameCellTemplate}">
          GridViewColumn>
          
          <GridViewColumn 
           HeaderTemplate="{StaticResource PackageColHeader}"
           CellTemplate="{StaticResource PackCellTemplate}">
          GridViewColumn>
        GridView>
      ListView.View>
    ListView> 

The markup for the DataTemplates and Styles is the same as that shown in the previous blog, all of which I placed in the Application.xaml file (App.xaml for C# projects).

There are some other row formatting options I want to cover, but I will leave those for another day.

Visual Studio 2010 XAML Intellisense and Other Improvements

Ged Mead — Sun, 25 Oct 2009 13:12:00 GMT

Sometimes it's the tiniest little changes that make you happy out of all proportion to the size of the change. While testing the WPF features in VS2010 I was totally thrilled to discover that at last when you type in the opening curly brace in the XAML Pane, you get an Intellisense list of useful choices. The top one, of course, is StaticResource. If I had a penny for every time I've laboriously typed out that name, I'd be a rich man!

The same feature also offers other commonly used properties such as Binding. And once you have entered 'Binding' and a space, you also get Path, again courtesy of Intellisense.

On the subject of DataBinding, which is a key feature in WPF of course, the Properties Pane has been improved. Now if you select a control such as a ListView, the ItemsSource property is available in the Properties Pane and you can select the Binding from the available choices:

Maybe I've missed a trick, though, because when I tried to drill deeper into the ListView components and looked at the binding for a GridViewColumn, there didn't seem to be a way to select a value for the DisplayMemberBinding. If in the XAML Pane I manually typed in a valid Path, i.e. a field from the data source behind the DataContext, then that would be shown in the Properties Pane. But I couldn't find an option to switch the Path to a different field within that dialog.

I quite liked the way you can now view and choose from all the Resources in scope. This example shows where I am building a ListView and using a CellTemplate, for instance:

I noticed that when using the Properties Pane in this way, it can have an annoying habit. You close the dialog window by clicking anywhere outside it (i.e. it doesn't have a close/x button). If you are careless about where you click, you will deselect the current element in the XAML Pane. Often, if you click in the Design Pane to deselect, you will be taken back to the root element. It would be nice if a close button is added to the dialog windows at some point.

You can also pick and assign a saved Style for the Style property of any element. In this example I am offered all the previously created styles which can be assigned to a TextBlock element:

Another super improvement in the Properties pane is the color picker feature. If you select a property which can be assigned a color (well, to be more accurate, a brush), then you can click on the little down arrow at the right hand side of the property in the Properties pane and a color picker dialog will appear:

This example shows the Background property of a TextBlock. You can play with the color picker until you have the exact look you want. if you've used Expression Blend you'll recognize this layout.

You can still select a named color if you want. The drop down list is at the bottom left of the color picker:

Overall, I like the new look of the VS2010 editor and the new features I've found so far.

Using the ElementHost in Visual Studio 2010

Ged Mead — Fri, 31 Jul 2009 20:52:00 GMT

I'm a big fan of WPF and WinForms Interop, so have often advised people to try the ElementHost when they want to do something graphically complex on a Windows Form. This useful little container allows you to create a WPF UserControl right there inside the WinForms project and then display those WPF graphics in a Windows Form.

One of the negative things about this in VS 2008 is that you always get a kind of error message inside the ElementHost at Design Time which reads "Unable to generate a preview". It's not really an error, but it is negative feedback.

Although this message is disconcerting at first, you soon get used to it, and the WPF UserControl will display nicely once you actually run the project.

I was hoping that VS 2010 would fix this issue and that you would be able to see the WPF content in the ElementHost right there on the Window at Design time. The good news is that you can. The bad news is that the pseudo-error has been replaced with a genuine error!

The error message is: "Type 'WindowsFormsIntegration.Design.HostedComponent' is not available in the target framework". This message appears whether you choose Version 3.5 or 4 of the .NET Framework for the project. I was particularly surprised that I still got the error with 3.5 apps. You wouldn't have thought that a problem with v4 would be a breaking change in the earlier Framework, but this seems to be the case.

Anyway, I did some searching and found the fix documented in the Microsoft .NET Framework 4 Beta 1 Readme. It requires an additional Reference which is tucked away in the Visual Studio 2010 sub-folder in the Program Files folder. The exact path in my installation is:

C:\Program Files\Microsoft Visual Studio 10.0\Common7\IDE\WindowsFormsIntegration.Design.dll

You have to use the 'Browse' Tab instead of the more usual .NET tab of course to find and add this dll. You may also see a further warning message regarding the use of this dll with earlier versions of the Framework. This indicates that if you have your Framework set to 3.5 you don't need this dll (because it is a Framework 4 requirement). However, I couldn't get ElementHost to work properly in either 3.5 or 4 mode before I added this Reference, so that all left me a little confused - but happy, because it now works as it should.

Having sorted that out, I can now see the WPF UserControl on the Windows Form at Design Time, as you can see from the screenshot below. This is much more useful because it is often necessary to tweak the layout of the UserControl or other settings to make it fit in with the layout of other Windows Forms controls on the Form. Now that I can see it at Design time, I don't have to keep running and re-running the project to see the effect of changes.

I hope that this requirement to add the reference will be fixed by the time the final version of VS 2010 ships, but in the meantime I'll not complain about the small amount of work needed to gain the additional benefit.

Don't forget that you should already have the standard:

PresentationCore
PresentationFramework
WindowsBase
WindowsFormsIntegration

References in place for this kind of Interop task.