http://www.archive.org/details/ol_data

among other things, archive.org provides library catalogues for download in various formats (json, xml, marc). some of these are very, very big. a particularly good one i’ve used a lot is the ‘open library json dump’ – 20gigs (43,000,000+ records) of juicy data.

http://blog.stackoverflow.com/2009/06/stack-overflow-creative-commons-data-dump/

a big chunk of posts, comments, authors etc. good data and very useful for simulating real-world scenarios

So, to turn this rant into something useful, I’ll talk about a useful trigger for grabbing a double click on UIElements (such as DataGrid).

The scenario is you have a list of items displayed in a DataGrid and want to select one by double clicking it. We’ll need to code two classes: 1. a trigger that fires on double click; 2. an action that can be fired in response to the trigger (e.g. an action that executes an ICommand).

The first step, is to create the trigger .cs file. Visual Studio 2008 and Blend 3 now provide templates for Triggers, Actions & Behaviors to get you started. Here’s what the template looks like in Visual Studio:

This creates the class, adds the necessary overrides and adds a reference to System.Windows.Interactivity.dll.

Now to implement the double click trigger. There’s not a lot of mystery about how to do this, and I borrowed the logic from this useful blog post: Silverlight 3 Behaviors : Double Click Trigger – but extended it in several key areas.

Firstly, I used UIElement.Addhandler() to attach the mouse events (MouseLeftButtonDown, MouseLeftButtonUp) in order to ensure the trigger works on UIElements that mark these events handled (like Button for instance).

Secondly, I wanted to be selective and intelligent about the parameter passed in to TriggerBase.InvokeActions(). The important thing here is that, in different circumstances, I’ll want to pass in different parameters. For instance, if the control that fired the trigger is a DataGrid, I’ll want to pass in the SelectedItem; if the control is a Selector, I’ll want to pass in the SelectedItem; or if the control is something else, I may want to pass in the DataContext.

In order to be as generic and extensible as possible, I decided to build a base class that I could inherit other classes from. Here’s my implementation:

using System;
using System.Windows;
using System.Windows.Threading;
using System.Windows.Input;
using System.Windows.Interactivity;

namespace GridClicker.Behaviors
{
    public class DoubleClickTriggerBase : TriggerBase<UIElement>
    {
        private readonly DispatcherTimer _timer;

        public DoubleClickTriggerBase()
        {
            _timer = new DispatcherTimer
            {
                Interval = new TimeSpan(0, 0, 0, 0, 200)
            };
            _timer.Tick += OnTimerTick;
        }

        protected override void OnAttached()
        {
            base.OnAttached();
            AssociatedObject.AddHandler(UIElement.MouseLeftButtonDownEvent,
                                        new MouseButtonEventHandler(OnMouseAction), true);
        }

        protected override void OnDetaching()
        {
            base.OnDetaching();
            AssociatedObject.RemoveHandler(UIElement.MouseLeftButtonDownEvent,
                                           new MouseButtonEventHandler(OnMouseAction));
            if (_timer.IsEnabled)
            {
                _timer.Stop();
            }
        }

        private void OnMouseAction(object sender, MouseButtonEventArgs e)
        {
            if (!_timer.IsEnabled)
            {
                _timer.Start();
                return;
            }
            _timer.Stop();
            DoInvoke();
        }

        private void OnTimerTick(object sender, EventArgs e)
        {
            _timer.Stop();
        }

        protected virtual void DoInvoke()
        {
            InvokeActions(null);
        }
    }
}

Here’s an inherited class, DataGridDoubleClickTrigger.cs:

using System.Windows.Controls;

namespace GridClicker.Behaviors
{
    public class DataGridDoubleClickTrigger : DoubleClickTriggerBase
    {
        protected override void DoInvoke()
        {
            var dg = AssociatedObject as DataGrid;
            var o = dg == null ? null : dg.SelectedItem;
            if (o != null)
            {
                InvokeActions(o);
            }
        }
    }
}

This simply passes in the SelectedItem of the DataGrid as the InvokeAction() parameter. Of course you could make any number of classes that inherit from DoubleClickTriggerBase. I should point out that there is an assumption here that the user will double click on a row of the DataGrid and not the header, though it will not break in any case. If a user does double click on the header of the DataGrid, if the SelectedItem is not null it will be returned, otherwise nothing will happen.

Now a trigger is no good without an action to fire, so here is a very quick and simplistic action that executes an ICommand. Firstly, create the action in Visual Studio:

And here’s the implementation:

using System.Windows;
using System.Windows.Input;
using System.Windows.Interactivity;

namespace GridClicker.Behaviors
{
    public class ExecuteCommandAction : TriggerAction<FrameworkElement>
    {
        public string CommandName { get; set; }

        protected override void Invoke(object o)
        {
            if (CommandName == null) return;
            var dataContext = AssociatedObject.DataContext;
            if (dataContext == null) return;
            var command = dataContext.GetType().GetProperty(CommandName).GetValue(dataContext, null) as ICommand;
            if (command != null && command.CanExecute(o))
            {
                command.Execute(o);
            }
        }
    }
}

Even though TriggerAction is a DependencyObject, it doesn’t seem to want to let you make CommandName a DependencyProperty and bind it’s value. No idea why this is, hence the roundabout route to grab the command.

To put it altogether, here is the XAML:

<StackPanel x:Name="ContentStackPanel">

    <TextBlock x:Name="HeaderText" Style="{StaticResource HeaderTextStyle}" 
                       Text="Home"/>

    <data:DataGrid ItemsSource="{Binding Categories}" IsReadOnly="True">
        <i:Interaction.Triggers>
            <b:DataGridDoubleClickTrigger>
                <b:ExecuteCommandAction CommandName="SelectCommand" />
            </b:DataGridDoubleClickTrigger>
        </i:Interaction.Triggers>
    </data:DataGrid>
    
    <Button Content="Double Click Button" Margin="10" VerticalAlignment="Center" HorizontalAlignment="Center">
        <i:Interaction.Triggers>
            <b:DoubleClickTriggerBase>
                <b:ExecuteCommandAction CommandName="ButtonCommand"/>
            </b:DoubleClickTriggerBase>
        </i:Interaction.Triggers>
    </Button>

</StackPanel>

Finally, to round things off, here is the view’s presenter:

public class HomePresenter : INotifyPropertyChanged
{
    public ICommand SelectCommand { get; private set; }
    public ICommand ButtonCommand { get; private set; }

    public HomePresenter()
    {
        SelectCommand = new DelegateCommand<object>(o =>
        {
            var cat = o as Category;
            var dw = new DetailsWindow {Width = 300.0, Height = 300.0};
            var g = dw.FindName("LayoutRoot") as Grid;
            g.Children.Add(new TextBlock()
            {
                Text = "Category Name: " + cat.CategoryName,
                HorizontalAlignment = HorizontalAlignment.Center,
                VerticalAlignment = VerticalAlignment.Center
            });
            dw.Show();
        });

        ButtonCommand = new DelegateCommand<object>(o => HtmlPage.Window.Alert("Button was double clicked!"));
    }

    public ObservableCollection<Category> Categories
    {
        get { return CategoryHelper.GetCategories(); }
    }

    public event PropertyChangedEventHandler PropertyChanged;
}

In the example I am using Prism’s DelegateCommand implementation of ICommand.

There you have it!

The first and most obvious technique is to simply show a confirm in the event handler of the button in code behind.

Take the following XAML:

<data:DataGrid ItemsSource="{Binding Categories}" AutoGenerateColumns="False">
    <data:DataGrid.Columns>
        <data:DataGridTextColumn Header="ID" Binding="{Binding CategoryID}" />
        <data:DataGridTextColumn Header="Name" Binding="{Binding CategoryName}" />
        <data:DataGridTemplateColumn Header="">
            <data:DataGridTemplateColumn.CellTemplate>
                <DataTemplate>
                    <Button Content="Delete" Click="Button_Click" />
                </DataTemplate>
            </data:DataGridTemplateColumn.CellTemplate>
        </data:DataGridTemplateColumn>
    </data:DataGrid.Columns>
</data:DataGrid>

private void Button_Click(object sender, RoutedEventArgs e)
{
	Category cat = (sender as Button).DataContext as Category;
	if (HtmlPage.Window.Confirm("Are you sure you want to delete that?"))
	{
		HtmlPage.Window.Alert("Deleted");
	}
}

Not a good solution in my case, however, as I wanted to use commanding to link my Delete button to an ICommand in the view’s presenter. (Prism gives a great implementation of ICommand – DelegateCommand<T>).

When you use commanding, the obvious place to put the confirm dialogue is in the presenter:

<data:DataGrid ItemsSource="{Binding Categories}" AutoGenerateColumns="False">
    <data:DataGrid.Columns>
        <data:DataGridTextColumn Header="ID" Binding="{Binding CategoryID}" />
        <data:DataGridTextColumn Header="Name" Binding="{Binding CategoryName}" />
        <data:DataGridTemplateColumn Header="">
            <data:DataGridTemplateColumn.CellTemplate>
                <DataTemplate>
                    <Button Content="Delete" cal:Click.Command="{Binding Path=Value, Source={StaticResource DeleteCommand}}"
                            cal:Click.CommandParameter="{Binding}"/>
                </DataTemplate>
            </data:DataGridTemplateColumn.CellTemplate>
        </data:DataGridTemplateColumn>
    </data:DataGrid.Columns>
</data:DataGrid>

and the DelegateCommand in the presenter:

DeleteCommand = new DelegateCommand<Category>((cat) =>
    {
        if (HtmlPage.Window.Confirm("Are you sure you want to delete that?"))
        {
            HtmlPage.Window.Alert("Deleted");
        }
    });

NOTE: Of course there’s an obvious problem with binding to an ICommand inside a DataTemplate – the DataContext is not the view (e.g. the view model or presenter) but the particular data item that the DataTemplate is displaying. You can get around this using RelativeSource binding in WPF, but not in Silverlight. The solution is to make your ICommand a StaticResource using a implementation of ObservableCommand, as described here: http://msdn.microsoft.com/en-us/library/dd458928.aspx

Now in the example above, the confirm dialogue certainly displays as I’d like it to, but I have philosophical objections to taking UI components (i.e. the dialogue) out of the view and sticking it in the presenter. Doing this also makes unit testing in the presenter a lot more difficult.

The first alternative that came to mind was to use the code-behind again, but this time invoke the ICommand from there, like this:

private void Click1(object sender, RoutedEventArgs e)
{
    ((HomePagePresenter)DataContext).DeleteCommand.Execute((sender as Button).DataContext as Category);
}

This is actually a fairly nice solution- the separation between the presenter and the view is maintained, the inconvenience of declaring the ICommand as a StaticResource is avoided, and it’s quite intuitive. It still seems a little inelegant, however – since all XAML purists will tell you that binding is better in every case.

The next solution I implemented is really nice. I created a new attached behaviour that extends Prism’s CommandBehaviorBase<T> called ConfirmClick. This lets me use the following mark-up:

<data:DataGrid ItemsSource="{Binding Categories}" AutoGenerateColumns="False" Grid.Row="1">
    <data:DataGrid.Columns>
        <data:DataGridTextColumn Header="ID" Binding="{Binding CategoryID}" />
        <data:DataGridTextColumn Header="Name" Binding="{Binding CategoryName}" />
        <data:DataGridTemplateColumn Header="">
            <data:DataGridTemplateColumn.CellTemplate>
                <DataTemplate>
                    <Button Content="Delete" cal2:ConfirmClick.Command="{Binding Path=Value, Source={StaticResource DeleteCommand}}"
                            cal2:ConfirmClick.CommandParameter="{Binding}"/>
                </DataTemplate>
            </data:DataGridTemplateColumn.CellTemplate>
        </data:DataGridTemplateColumn>
    </data:DataGrid.Columns>
</data:DataGrid>

I won’t include the two files ButtonBaseConfirmClickCommandBehavior.cs & ConfirmClick.cs here as they are quite lengthy, but download the source code at the end of this post if you want them.

This approach totally abstracts the out the creation of the confirm dialogue so I don’t have to think about it at all. It’s neat, reusable and fits the pattern perfectly.

I could have stopped here, but there was one other avenue I wanted to check: the new Behaviours that come as part of Silverlight 3. Behaviours are divided into three broad categories: Triggers, Actions and Behaviors. In my case, I can use the inbuilt EventTrigger trigger and attach it to the Click event of my Button.

Don’t forget that if you want to use Behaviors, you need to reference Microsoft.Expression.Interactivity.dll from you project and import the namespace into the XAML.

Now that I can trap the Interestingly, the Microsoft.Expression.Interactivity implements an InvokeCommandAction which I couldn’t for the life of me get to work. It doesn’t help that it is not mentioned anywhere in the Silverlight 3 documentation. Not to worry, I ended up implementing my own Action which looks for an ICommand in the FrameworkElement.Tag property. Here’s the XAML:

<data:DataGrid ItemsSource="{Binding Categories}" AutoGenerateColumns="False" Grid.Row="2">
    <data:DataGrid.Columns>
        <data:DataGridTextColumn Header="ID" Binding="{Binding CategoryID}" />
        <data:DataGridTextColumn Header="Name" Binding="{Binding CategoryName}" />
        <data:DataGridTemplateColumn Header="">
            <data:DataGridTemplateColumn.CellTemplate>
                <DataTemplate>
                    <Button Content="Delete" Tag="{Binding Path=Value, Source={StaticResource DeleteCommand}}">
                        <i:Interaction.Triggers>
                            <i:EventTrigger EventName="Click">
                                <loc:ConfirmCommandAction />
                            </i:EventTrigger>
                        </i:Interaction.Triggers>
                    </Button>
                </DataTemplate>
            </data:DataGridTemplateColumn.CellTemplate>
        </data:DataGridTemplateColumn>
    </data:DataGrid.Columns>
</data:DataGrid>

And the Action looks like this:

public class ConfirmCommandAction : TriggerAction<FrameworkElement>
{
    private string message;
    public string Message
    {
        get { return message ?? "Are you sure you want to do that?"; }
        set { message = value; }
    }
    protected override void Invoke(object parameter)
    {
        if (AssociatedObject.Tag is ICommand)
        {
            var cmnd = AssociatedObject.Tag as ICommand;
            if (cmnd != null && cmnd.CanExecute(AssociatedObject.DataContext))
            {
                if (HtmlPage.Window.Confirm(Message))
                {
                    cmnd.Execute(AssociatedObject.DataContext);
                }
            }
        }
    }
}

I should point out that my implementation of ConfirmCommandAction was pretty rapid  and has some holes in it. For instance, I’m not sure I like assuming that the DataContext of the AssociatedObject should be passed as the parameter of the ICommand. I’m also a little unsure whether the Tag property was really supposed to be used like that. Nevertheless it all works quite nicely.

So, there’s several techniques for implementing a confirm dialogue on an ICommand. I think each is valid in it’s own way, but my money is on the ConfirmClick attached behaviour as the most elegant solution – providing you’re willing to include some of the Prism libraries in your project.

Hope you find it useful!

UPDATE: I bumped into Nikhil Kothari on Twitter and he mentioned that the eventing model for DomainContext is changing in the July CTP (going to become a lot more intuitive when dealing with multiple concurrent calls)…

The more time I spend working with .NET RIA services, the more I like it. That said, it’s not without it’s frustrations. Today I spent a good part of the afternoon writing some Silverlight test cases and found myself repeating a stack of awkward, ugly code.

Most of the example code I’ve seen around the web is pretty simplistic and doesn’t deal with DomainContext classes that make multiple calls (submits and loads). I’m sure this will change as ria services mature, but at the moment rich examples are hard to come by.

The issue I was having was tracking which call was returning in two of the main events that a DomainContext raises: Loaded and Submitted. These  events are useful in the sense that they tell you when your call has completed, but if you’ve made multiple calls simultaneously then it’s not easy to tell which call is the one that has raised the event. For instance, when the Loaded event is raised, the LoadedDataEventArgs gives you access to a LoadedEntities property which holds the collection of newly loaded entities. You could then check the type of the first entity in order to see which load call has completed, but this is not a great solution as a call may have returned null (i.e. zero results)

Enter UserState. I actually couldn’t find much documentation on this one, but in a nutshell, it is a parameter of type object that you can pass into load and submit methods of your DomainContext and get back in the LoadedDataEventArgs and SubmittedChangesEventArgs.

On the most simple level you could call a method, say, LoadById() and pass in an int, say 1. When the Loaded event is raised after the call, you get back the LoadedDataEventArgs which now carries a property called UserState which is an int with a value of 1. Nice!

After reading around a bit on the Silverlight forums, I decided on the following approach to streamline things further.

Firstly, I created a delegate in the presenter of my view.

private delegate void CompletedDelegate(EventArgs args);

Secondly, I hooked up a reusable method to the Loaded and Submitted events of my DomainContext. The idea is to take the events’ EventArgs and have a look if they have a UserState property that is the delegate type we are after. Here’s the method:

private void contextEventHandler(EventArgs args)
{
    if (args is LoadedDataEventArgs)
    {
        if (((LoadedDataEventArgs)args).UserState is CompletedDelegate)
        {
            ((CompletedDelegate)((LoadedDataEventArgs)args).UserState).Invoke(args);
        }
    }
    else if (args is SubmittedChangesEventArgs)
    {
        if (((SubmittedChangesEventArgs)args).UserState is CompletedDelegate)
        {
            ((CompletedDelegate)((SubmittedChangesEventArgs)args).UserState).Invoke(args);
        }
    }
}

public HomePagePresenter(HomePage view)
{
    this.view = view;

    catCtxt = new CategoryDomainContext();
    catCtxt.Loaded += (s, e) => contextEventHandler(e);
    catCtxt.Submitted += (s, e) => contextEventHandler(e);

    view.Click += (s, e) =>
        {
            if ((s as Button).Tag.ToString() == "Save")
            {
                catCtxt.SubmitChanges(new CompletedDelegate(dataSubmitted));
            }
            else if ((s as Button).Tag.ToString() == "Reject")
            {
                catCtxt.RejectChanges();
            }
        };

    loadData();
}

The key part of the above is catCtxt.SubmitChanges(new CompletedDelegate(dataSubmitted)); which sets the UserState as the delegate. Now, when the call to submit completes, the method dataSubmitted will be called. Here is that method:

private void dataSubmitted(EventArgs e)
{
    SubmittedChangesEventArgs args = e as SubmittedChangesEventArgs;
    if (args.Error != null)
    {
        HtmlPage.Window.Alert(args.Error.Message);
    }
    else
    {
        HtmlPage.Window.Alert("Data submission complete");
    }
}

Finally, it’s worth taking a look at the loadData() method which again passes in a delegate as UserState:

private void loadData()
{
    catCtxt.LoadCategories(null, new CompletedDelegate(dataLoaded));
}

And the dataLoaded method:

private void dataLoaded(EventArgs e)
{
    notifyChange("Categories");
}

And to road off the code bits, here’s the simplistic DomainService class I used in the example:

[EnableClientAccess()]
public class CategoryDomainService : DomainService
{
    public IQueryable<Category> GetCategories()
    {
        return CategoryHelper.GetCategories().AsQueryable();
    }

    public void InsertCategory(Category cat)
    {
    }

    public void UpdateCategory(Category newCat, Category originalCat)
    {
    }

    public void DeleteCategory(Category cat)
    {
    }
}

All in all I was pretty happy with this technique. It seemed to make ria services a little more WCF-like to me, while still retaining all the major benefits of ria services. The code is still pretty rough, but hey – all my test cases are now passing and the code is a lot more readable than it was. Happy days!

NOTE: It’s probably worth pointing out that the July CTP of ria services may well render this example obsolete when it comes out. soon i hope!!!

The original pressure for my team to adopt RIA services was mainly driven by the nice end-to-end data validation framework that it ships with. We started rolling our own and it quickly became clear how much work it was going to take, and – let’s be fair – nobody likes writing that sort of code. If you haven’t checked it out already, a good place to start is over at Brad Abrams’ blog.

A key goal of RIA services is to simplify n-tier architectures, and it does this by creating a link between a ASP.NET web application project and a Silverlight application project and generating a lot of code that is magically shared between the two. I won’t go into this in any detail, because it’s not the point of this post.

One of the big issues I hit first up is this: once you install the RIA services pack, you are given the ability to link a ASP.NET web application project with a Silverlight application, but not a Silverlight class library. My particular usage scenario means I need to share a service DLL  amongst a bunch of XAPs (i.e. modules of a Prism solution) , so it’s no good for me to have a direct link between the RIA services web app and a Silverlight app (e.g. the Prism shell). I need a library I can share between all my modules.

When you create a new web application project, you get the following option:

Alternatively, you can go into the properties of a Silverlight application and link the server project there:

But strangely enough, these options don’t exist when you are dealing with a Silverlight class library.

The work around is this: create you ASP.NET web application and then create your Silverlight class library. The two aren’t linked yet. Exit visual studio and open the .csproj file of the class library project. You want to add the following:

<PropertyGroup>
	....
	<LinkedServerProject>..\SilverlightApplication1.Web\SilverlightApplication1.Web.csproj</LinkedServerProject>
	...
</PropertyGroup>

Now when you re-open visual studio and build your web application project (assuming it has some domain service classes in it) you’ll see the generated code in your Silverlight class library.

I should probably note that this will all probably change by the time the July CTP comes out (Brad Abrams implied as much in a twitter response to my question).

Last night I witnessed the first ever meeting of the Silverlight Designer and Developer Network – a new Silverlight user group here in Melbourne. Turnout was huge for a first time and the quality of the presented material was great. In particular, I have to say I was blown away by Jonas Follesø’s presentation (a Norwegian Microsoft guy). Not only did he turn out *lots* of code by hand by he actually covered some really cool topics (which I didn’t expect at this sort of event). He covered the Silverlight Toolkit (nothing new here), Live Mesh & Silverlight outside the browser (wow! this one got the gears of my brain turning) as well as the as-yet nameless Silverlight Business FX Framework which I’m thinking will be part of Silverlight 3 (we could take weeks/months off our project if this was available now!). So I walked away pretty happy and very positive about putting myself in the Silverlight camp for the foreseeable future.

Better get to some code….

A very quick post today. In the course of today I realised needed to unify our approach to managing the UI during asynchronous loads. Basically, the scenario is where you have a control that displays some piece of data that needs to be fetched, and the fetching may take several seconds (or more). Obviously you need to block any user interaction with the control before it is fully loaded, and to follow the convention, you should probably also throw a translucent layer over the control and display a snazzy loading graphic. And of course, a major consideration for me was to make a control I could re-use throughout my app.

Here’s what I’m making:

The way I decided to approach this was to make a very minor extension to a ContentControl – adding an extra piece of content to hold the ‘waiting’ layer, and an IsLoading property to manage the visual state of the control (i.e. loading or normal). To manage the different visual states, Silverlight provides the handy Visual State Manager. Using the VSM, you can define the visual appearance of your control when it is in certain states (or combinations of states). The Loading Panel can only ever be in two states: Normal and Loading. When the control is in the loading state, the ‘waiting’ layer has it’s visibility set to visible.

Here’s the XAML:

<ResourceDictionary
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
    xmlns:vsm="clr-namespace:System.Windows;assembly=System.Windows"
    xmlns:loc="clr-namespace:LoadingPanel"
    >
    <Style TargetType="loc:LoadingPanel">
        <Setter Property="Template">
            <Setter.Value>
                <ControlTemplate TargetType="loc:LoadingPanel">
                    <Grid>
                        <vsm:VisualStateManager.VisualStateGroups>
                            <vsm:VisualStateGroup x:Name="CommonStates">
                                <vsm:VisualState x:Name="Loading">
                                    <Storyboard>
                                        <ObjectAnimationUsingKeyFrames 
                                            Storyboard.TargetName="frameworkelementLoadingContent" 
                                            Storyboard.TargetProperty="Visibility" Duration="0">
                                            <DiscreteObjectKeyFrame KeyTime="0">
                                                <DiscreteObjectKeyFrame.Value>
                                                    <Visibility>Visible</Visibility>
                                                </DiscreteObjectKeyFrame.Value>
                                            </DiscreteObjectKeyFrame>
                                        </ObjectAnimationUsingKeyFrames>
                                    </Storyboard>
                                </vsm:VisualState>
                                <vsm:VisualState x:Name="Normal"/>
                            </vsm:VisualStateGroup>
                        </vsm:VisualStateManager.VisualStateGroups>
                        <ContentPresenter Content="{TemplateBinding Content}"/>
                        <ContentPresenter x:Name="frameworkelementLoadingContent" 
                                          Content="{TemplateBinding LoadingContent}"
                                          Visibility="Collapsed"/>
                    </Grid>
                </ControlTemplate>
            </Setter.Value>
        </Setter>
    </Style>
</ResourceDictionary>

There’s little that needs explaining here, since the control comprises little more than two ContentPresenters to hold the pieces of content. The VSM also enables you to se transitions between states, but since our designers haven’t asked for anything I’ve purposely left this out.

In our case, when the control is put into ‘Loading’ mode, there’s a basic Storyboard with a single animation occurring after 0 seconds (the change from collapsed to visible) targeted at the ‘waiting’ content presenter. This particular control uses only one VisualStateGroup, but with more complex controls, you can use several of these to describe different sets of visual characteristics that may or may not be valid in conjunction with other visual states.

The LoadingPanel.cs is a little more interesting. Here’s the code:

using System;
using System.Windows;
using System.Windows.Controls;
 
namespace LoadingPanel
{
    public class LoadingPanel : ContentControl
    {
        public LoadingPanel()
        {
            DefaultStyleKey = typeof(LoadingPanel);
            IsLoading = false;
        }
 
        public override void OnApplyTemplate()
        {
            base.OnApplyTemplate();
            GoToState();
        }
 
        private void GoToState()
        {
            if (IsLoading)
            {
                VisualStateManager.GoToState(this, "Loading", false);
            }
            else
            {
                VisualStateManager.GoToState(this, "Normal", false);
            }
        }
 
        public static DependencyProperty IsLoadingProperty =
            DependencyProperty.Register("IsLoading", typeof(bool), typeof(LoadingPanel),
            new PropertyMetadata(new PropertyChangedCallback((d, e) =>
            {
                LoadingPanel lp = d as LoadingPanel;
                lp.GoToState();
            })));
 
        public bool IsLoading
        {
            get { return (bool)GetValue(IsLoadingProperty); }
            set { SetValue(IsLoadingProperty, value); }
        }
 
        public static readonly DependencyProperty LoadingContentProperty =
            DependencyProperty.Register("LoadingContent", typeof(object), typeof(LoadingPanel), null);
 
        public object LoadingContent
        {
            get { return (object)GetValue(LoadingContentProperty); }
            set { SetValue(LoadingContentProperty, value); }
        }
    }
}

A few things worth pointing out:

• The constructor is useful for setting default values for the control’s properties
• The GotoState() method is, by convention, a helper method that interacts with the VisualStateManager
• I haven’t touched the Control Contract at all. This is a series of class Attributes that describe the various parts and states of the control – consumed by Blend. If you don’t plan to use the control in Blend then there’s  no need for a Control Contract, but apparently it’s good practice to leave it in anyway. Karen Corby wrote a good post about this.

Here’s how to use the control in your XAML:

<UserControl 
    x:Class="LoadingPanelSL.Page"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
    xmlns:data="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Data"
    xmlns:lp="clr-namespace:LoadingPanel;assembly=LoadingPanel"
    >
    <Grid x:Name="LayoutRoot">
        
        <Grid Width="400" Height="400">
            <Grid.RowDefinitions>
                <RowDefinition Height="*" />
                <RowDefinition Height="Auto" />
            </Grid.RowDefinitions>
 
            <lp:LoadingPanel IsLoading="{Binding IsLoading}">
                <lp:LoadingPanel.Content>
                    <data:DataGrid x:Name="datagridMyGrid" ItemsSource="{Binding MyData}" />
                </lp:LoadingPanel.Content>
                <lp:LoadingPanel.LoadingContent>
                    <Grid>
                        <Rectangle Fill="LightSlateGray" Opacity="0.3" />
                        <TextBlock Text="Loading..." 
                                   HorizontalAlignment="Center" 
                                   VerticalAlignment="Center" 
                                   Opacity="0.7" FontSize="16" />
                    </Grid>
                </lp:LoadingPanel.LoadingContent>
            </lp:LoadingPanel>
            
            <Button Content="Load Data" x:Name="buttonLoadData" Grid.Row="1" />
        </Grid>
        
    </Grid>
</UserControl>

Note the two attached properties: Content (inherited from ContentControl) and LoadingContent which is a dependency property I added. You should put the data control in the Content tag and the ‘waiting’ screen in the LoadingContent tag.

The thing that makes this technique very simple to use is being able to databind the IsLoading property. It becomes very simple to flick the IsLoading property from true to false in your presenter and know that the UI side of things is taken care of.

And finally, the code-behind:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media.Animation;
using System.ComponentModel;
 
namespace LoadingPanelSL
{
    public partial class Page : UserControl
    {
        public Page()
        {
            InitializeComponent();
            this.DataContext = new MyDataContext(this);
        }
    }
 
    public class MyDataContext : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;
        private readonly UserControl view;
 
        public MyDataContext(UserControl view)
        {
            this.view = view;
 
            MyDataService service = new MyDataService();
            service.DataLoaded += (object s, MyDataEventArgs e) =>
                {
                    IsLoading = false;
                    MyData = e.Data;
                };
 
            Button b = view.FindName("buttonLoadData") as Button;
            b.Click += (s, e) =>
                {
                    IsLoading = true;
                    service.GetData();
                };
        }
 
        private IEnumerable<string> myData;
        public IEnumerable<string> MyData
        {
            get { return myData; }
            set { myData = value; NotifyChange("MyData"); }
        }
 
        private bool isLoading = false;
        public bool IsLoading
        {
            get { return isLoading; }
            set { isLoading = value; NotifyChange("IsLoading"); }
        }
 
        private void NotifyChange(string name)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(name));
            }
        }
    }
 
    public class MyDataService
    {
        public event EventHandler<MyDataEventArgs> DataLoaded;
        private string[] str = ("Microsoft Silverlight extends your existing " +
            "development skills empowering you to build new types of applications " +
            "for the Web regardless of target platform or browser Rapidly create " +
            "compelling rich Web applications using all the familiar features " +
            "languages and tools of the .NET framework").Split();
 
        public void GetData()
        {
            Random rand = new Random();
            Storyboard sb = new Storyboard();
            sb.Duration = new Duration(TimeSpan.FromSeconds(3));
            sb.Completed += new EventHandler((s, e) =>
                {
                    OnDataLoaded(new MyDataEventArgs(from st in str orderby rand.Next() select st));
                });
            sb.Begin();
        }
 
        private void OnDataLoaded(MyDataEventArgs e)
        {
            if (DataLoaded != null) DataLoaded(this, e);
        }
    }
 
    public class MyDataEventArgs : EventArgs
    {
        public IEnumerable<string> Data { get; set; }
        public MyDataEventArgs(IEnumerable<string> data)
        {
            Data = data;
        }
    }
}

There’s a bit of junk code here to generate ‘random’ data and simulate an asynchronous request. Nevertheless, the code flow is somewhat similar to the way you find your self working with WCF services in a real LOB app.

If I had time there’s any number of improvements I’d make to this, but what sort of software developer has time?  This is exactly the sort of quick and dirty solution that makes Silverlight so fun to work with.

One of the first things I needed to do with the new control was rig up a TreeView for some data. Sounds pretty easy, and it is – if you data happen to be in the right structure for the data binding. Reading the docos I discovered that in order to display hierarchical data to the nth level, I need objects that contain collections of their child objects. Damn! For a moment I thought this would mean either changes to the business objects (unlikely) or some sort of conversion layer to covert my business objects into hierarchical objects.

Before we get any further, this is what I am making:

To explain what I mean, this is how my business objects were structured:

public class Person
{
    public Person() { PersonID = 0; }
    public int PersonID { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string JobTitle { get; set; }
    public Person Manager { get; set; }
}

So, in my objects, I carry an instance of the parent, not a collection of the children. This is fairly standard stuff, so I figured there must be a neat way to make a collection of objects like this bind to a tree view.

Convert flat collection to hierarchy using LINQ

In my reading I came across a blog post by a guy name Stefan Cruysberghs (LINQ AsHierarchy) which demonstrates how to use an extension method to dynamically convert flat objects into hierarchical ones. What a great idea! I highly recommend you read his post.

I needed to make a minor customization to the source provided by Stefan: I threw in an extra method that allows you to specify the parent ids that root nodes should have, but other than that, everything is the same. Here is my altered code:

using System;
using System.Linq;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;

/// <summary>
/// Hierarchy node class which contains a nested collection of hierarchy nodes
/// </summary>
/// <typeparam name="T">Entity</typeparam>
public class HierarchyNode<T> where T : class
{
    public T Entity { get; set; }
    public IEnumerable<HierarchyNode<T>> ChildNodes { get; set; }
    public int Depth { get; set; }
    public T Parent { get; set; }
}

// Stefan Cruysberghs, July 2008, http://www.scip.be
/// <summary>
/// AsHierarchy extension methods for LINQ to Objects IEnumerable
/// </summary>
public static class LinqToObjectsExtensionMethods
{
    private static IEnumerable<HierarchyNode<TEntity>>
      CreateHierarchy<TEntity, TProperty>(
        IEnumerable<TEntity> allItems,
        TEntity parentItem,
        Func<TEntity, TProperty> idProperty,
        Func<TEntity, TProperty> parentIdProperty,
        object rootItemId,
        object rootParentId,
        int maxDepth,
        int depth) where TEntity : class
    {
        IEnumerable<TEntity> childs;

        if (rootItemId != null)
        {
            childs = allItems.Where(i => idProperty(i).Equals(rootItemId));
        }
        else if (rootParentId != null)
        {
            childs = allItems.Where(i => parentIdProperty(i).Equals(rootParentId));
        }
        else
        {
            if (parentItem == null)
            {
                childs = allItems.Where(i => parentIdProperty(i).Equals(default(TEntity)));
            }
            else
            {
                childs = allItems.Where(i => parentIdProperty(i).Equals(idProperty(parentItem)));
            }
        }

        if (childs.Count() > 0)
        {
            depth++;

            if ((depth <= maxDepth) || (maxDepth == 0))
            {
                foreach (var item in childs)
                    yield return
                      new HierarchyNode<TEntity>()
                      {
                          Entity = item,
                          ChildNodes =
                            CreateHierarchy(allItems.AsEnumerable(), item, idProperty, parentIdProperty, null, null, maxDepth, depth),
                          Depth = depth,
                          Parent = parentItem
                      };
            }
        }
    }

    /// <summary>
    /// LINQ to Objects (IEnumerable) AsHierachy() extension method
    /// </summary>
    /// <typeparam name="TEntity">Entity class</typeparam>
    /// <typeparam name="TProperty">Property of entity class</typeparam>
    /// <param name="allItems">Flat collection of entities</param>
    /// <param name="idProperty">Func delegete to Id/Key of entity</param>
    /// <param name="parentIdProperty">Func delegete to parent Id/Key</param>
    /// <returns>Hierarchical structure of entities</returns>
    public static IEnumerable<HierarchyNode<TEntity>> AsHierarchy<TEntity, TProperty>(
      this IEnumerable<TEntity> allItems,
      Func<TEntity, TProperty> idProperty,
      Func<TEntity, TProperty> parentIdProperty) where TEntity : class
    {
        return CreateHierarchy(allItems, default(TEntity), idProperty, parentIdProperty, null, null, 0, 0);
    }

    /// <summary>
    /// LINQ to Objects (IEnumerable) AsHierachy() extension method
    /// </summary>
    /// <typeparam name="TEntity">Entity class</typeparam>
    /// <typeparam name="TProperty">Property of entity class</typeparam>
    /// <param name="allItems">Flat collection of entities</param>
    /// <param name="idProperty">Func delegete to Id/Key of entity</param>
    /// <param name="parentIdProperty">Func delegete to parent Id/Key</param>
    /// <param name="rootItemId">Value of root item Id/Key</param>
    /// <returns>Hierarchical structure of entities</returns>
    public static IEnumerable<HierarchyNode<TEntity>> AsHierarchy<TEntity, TProperty>(
      this IEnumerable<TEntity> allItems,
      Func<TEntity, TProperty> idProperty,
      Func<TEntity, TProperty> parentIdProperty,
      object rootItemId) where TEntity : class
    {
        return CreateHierarchy(allItems, default(TEntity), idProperty, parentIdProperty, rootItemId, null, 0, 0);
    }

    /// <summary>
    /// LINQ to Objects (IEnumerable) AsHierachy() extension method
    /// </summary>
    /// <typeparam name="TEntity">Entity class</typeparam>
    /// <typeparam name="TProperty">Property of entity class</typeparam>
    /// <param name="allItems">Flat collection of entities</param>
    /// <param name="idProperty">Func delegete to Id/Key of entity</param>
    /// <param name="parentIdProperty">Func delegete to parent Id/Key</param>
    /// <param name="rootItemId">Value of root item Id/Key</param>
    /// <returns>Hierarchical structure of entities</returns>
    public static IEnumerable<HierarchyNode<TEntity>> AsHierarchy<TEntity, TProperty>(
      this IEnumerable<TEntity> allItems,
      Func<TEntity, TProperty> idProperty,
      Func<TEntity, TProperty> parentIdProperty,
      object rootItemId,
      object rootParentId) where TEntity : class
    {
        return CreateHierarchy(allItems, default(TEntity), idProperty, parentIdProperty, rootItemId, rootParentId, 0, 0);
    }

    /// <summary>
    /// LINQ to Objects (IEnumerable) AsHierachy() extension method
    /// </summary>
    /// <typeparam name="TEntity">Entity class</typeparam>
    /// <typeparam name="TProperty">Property of entity class</typeparam>
    /// <param name="allItems">Flat collection of entities</param>
    /// <param name="idProperty">Func delegete to Id/Key of entity</param>
    /// <param name="parentIdProperty">Func delegete to parent Id/Key</param>
    /// <param name="rootItemId">Value of root item Id/Key</param>
    /// <param name="maxDepth">Maximum depth of tree</param>
    /// <returns>Hierarchical structure of entities</returns>
    public static IEnumerable<HierarchyNode<TEntity>> AsHierarchy<TEntity, TProperty>(
      this IEnumerable<TEntity> allItems,
      Func<TEntity, TProperty> idProperty,
      Func<TEntity, TProperty> parentIdProperty,
      object rootItemId,
      object rootParentId,
      int maxDepth) where TEntity : class
    {
        return CreateHierarchy(allItems, default(TEntity), idProperty, parentIdProperty, rootItemId, rootParentId, maxDepth, 0);
    }
}

Using this technique, I quickly converted my flat collection in a hierarchical one and bound it to my treeview. Great!

Implementing the conversion via an IValueConverter

The solution still seemed a bit messy, so I hooked it up to an IValueConverter to make the conversion automatic and seamless. The less code the better, right? The IValueConverter interface is incredibly useful (I’ve been using it all week to display different ItemTemplate content in an ItemsControl depending what the data is). Basically, it grabs data during data binding and lets you examine / alter / replace data while it moves from the data source to the destination. In my case, I want to bind the ItemsSource of a TreeView to a flat collection of objects, but I wanted the TreeView to receive a hierarchical collection of objects. Here’s my converter:

public class HierarchyConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        ObservableCollection<Person> p = (ObservableCollection<Person>)value;
        var tree = p.AsHierarchy(e => e.PersonID, e => e.Manager.PersonID, null, 0);
        return tree;
    }
    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        throw new NotImplementedException();
    }
}

Wrap Up

Using this technique, I took  a flat collection of business objects and dynamically converted it to a hierarchical collection of node objects at run-time. Once again this is an instance where I expected something to be painful and involve writing a lot of boring code, but Silverlight managed to give me a really nice, elegant solution that I can re-use throughout my app.

I have done  some experimentation, though, and if you want to get two-way data binding to work for you, then you’ll have to drop the IValueConverter part. This is becuase the Convert() method is called when the initial binding takes place to the TreeView’s ItemsSource, but at no time will the ConvertBack() method be called – even if you specify fields in your Hierarchical ItemTemplate to have two-way binding. I still use the AsHierarchy extension method for a quick conversion when I am using two-way data binding however.

Here’s the Page.xaml:

<UserControl
    x:Class="LinqTree.Page"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:controls="clr-namespace:Microsoft.Windows.Controls;assembly=Microsoft.Windows.Controls"
    xmlns:local="clr-namespace:LinqTree"
    >
    <Grid x:Name="LayoutRoot" Background="White" Width="400" Height="470">
        <Grid.Resources>
            <local:HierarchyConverter x:Key="HierarchyConverter" />
            <Style x:Key="NameStyle" TargetType="TextBlock">
                <Setter Property="FontSize" Value="14" />
            </Style>
            <Style x:Key="JobTitleStyle" TargetType="TextBlock">
                <Setter Property="FontSize" Value="12" />
                <Setter Property="Foreground" Value="LightGray" />
                <Setter Property="FontStyle" Value="Italic" />
            </Style>
            <Style x:Key="MainBorder" TargetType="Border">
                <Setter Property="Background" Value="WhiteSmoke" />
                <Setter Property="BorderThickness" Value="1" />
                <Setter Property="CornerRadius" Value="8" />
                <Setter Property="BorderBrush" Value="LightGray" />
                <Setter Property="Padding" Value="12" />
            </Style>
        </Grid.Resources>
        <Border Style="{StaticResource MainBorder}">
            <controls:TreeView
            x:Name="treeview"
            ItemsSource="{Binding Converter={StaticResource HierarchyConverter}}">
                <controls:TreeView.ItemTemplate>
                    <controls:HierarchicalDataTemplate ItemsSource="{Binding ChildNodes}">
                        <StackPanel Orientation="Vertical">
                            <StackPanel Orientation="Horizontal">
                                <TextBlock Style="{StaticResource NameStyle}" Text="{Binding Entity.FirstName}" />
                                <TextBlock Text=" " />
                                <TextBlock Style="{StaticResource NameStyle}" Text="{Binding Entity.LastName}" />
                            </StackPanel>
                            <StackPanel Orientation="Horizontal">
                                <TextBlock Style="{StaticResource JobTitleStyle}" Text="{Binding Entity.JobTitle}" />
                            </StackPanel>
                        </StackPanel>
                    </controls:HierarchicalDataTemplate>
                </controls:TreeView.ItemTemplate>
            </controls:TreeView>
        </Border>
    </Grid>
</UserControl>

And here’s  the code behind (Page.xaml.cs):

using System;
using System.Collections.ObjectModel;
using System.Windows.Controls;

namespace LinqTree
{
    public partial class Page : UserControl
    {
        public Page()
        {
            InitializeComponent();
            ObservableCollection<Person> Persons = PersonCollection.PersonList();
            treeview.DataContext = Persons;
        }
    }
}

A nice clean solution to a common problem.

Now, to get to the code…
A fairly common scenario I encounter is needing to display a UI for objects with one-to-many relationships with other objects, for example a person who has one or more addresses (shipping, billing, etc). The other day I needed to whip up a really quick and dirty view in Silverlight to do this, and it occurred to me that it might be a good place to use the rich control templating features rather than making a whole new control by extending, say, ItemsControl. A key consideration is, of course, to make a reusable component that can be dropped anywhere in my app. The component also needs to support data binding, and fit in with the patterns & practises of the rest of the project (we are using Prism).

Here’s a screenshot of what I am creating:

Overview

The widget depicted in the screenshot above comprises some basic form components and a templated ListBox. Each address is a ListBoxItem: the ListBox is templated in such a way as to make Selected ListBoxItems visible and Unselected ListBoxItems hidden.

The ItemsSource of the ListBox and the ItemsSource of the Addresses ComboBox are data bound to the same collection of Addresses. The SelectedIndex of the ListBox and the SelectedIndex of the Address(es) ComboBox are data bound to an integer Property in the DataContext of the UserControl: when the selection in the ComboBox changes, the corresponding ListBoxItem is made visible in the ListBox below.

Since re-use is a big goal, I want to create new styles and templates for ListBox and ListBoxItem, and store them somewhere accessible like my App.xaml. This way, I can use a ListBox anywhere in my app and use these  styles – the ItemTemplate of the ListBoxItem can be customized on each use.

Customizing the ListBox

In my experience, when customizing an existing control, it is best to start by looking at that control’s default styles and templates. The source of all Silverlight’s controls can be obtained from Codeplex, but I also find the documentation on MSDN to be pretty good. I found a particularly helpful article here: ListBox Styles and Templates that gave me a great start.
The two controls I’ll need to customize are ListBox and ListBoxItem. Here are the default styles and templates for ListBox in XAML:

<Style TargetType="ListBox">
  <Setter Property="Padding" Value="1"/>
  <Setter Property="Background" Value="#FFFFFFFF" />
  <Setter Property="Foreground" Value="#FF333333" />
  <Setter Property="HorizontalContentAlignment" Value="Left" />
  <Setter Property="VerticalContentAlignment" Value="Top" />
  <Setter Property="IsTabStop" Value="False" />
  <Setter Property="BorderThickness" Value="1" />
  <Setter Property="TabNavigation" Value="Once" />
  <Setter Property="BorderBrush">
    <Setter.Value>
      <LinearGradientBrush EndPoint="0.5,1" StartPoint="0.5,0">
        <GradientStop Color="#FFA3AEB9" Offset="0"/>
        <GradientStop Color="#FF8399A9" Offset="0.375"/>
        <GradientStop Color="#FF718597" Offset="0.375"/>
        <GradientStop Color="#FF617584" Offset="1"/>
      </LinearGradientBrush>
    </Setter.Value>
  </Setter>
  <Setter Property="Template">
    <Setter.Value>
      <ControlTemplate TargetType="ListBox">
        <Border CornerRadius="2"
                    BorderBrush="{TemplateBinding BorderBrush}"
                  BorderThickness="{TemplateBinding BorderThickness}">
          <ScrollViewer x:Name="ScrollViewer" Padding="{TemplateBinding Padding}"
                        Background="{TemplateBinding Background}"
                        BorderBrush="Transparent" BorderThickness="0">
            <ItemsPresenter />
          </ScrollViewer>
        </Border>
      </ControlTemplate>
    </Setter.Value>
  </Setter>
</Style>

Looking at ListBox, the major area of interest is the ControlTemplate; the rest is just very basic style stuff. The ControlTemplate lays out the various bits and pieces that go together to make a ListBox – and most notably it includes an ItemsPresenter which marks the place where the ListBoxItems will be positioned. For my purposes, I”ll need to strip out some of the style info and remove the ScrollViewer (which isn’t needed in this case).

And here are the default styles and templates for ListBoxItem in XAML:

<Style TargetType="ListBoxItem">
  <Setter Property="Padding" Value="3" />
  <Setter Property="HorizontalContentAlignment" Value="Left" />
  <Setter Property="VerticalContentAlignment" Value="Top" />
  <Setter Property="Background" Value="Transparent" />
  <Setter Property="BorderThickness" Value="1"/>
  <Setter Property="TabNavigation" Value="Local" />
  <Setter Property="Template">
    <Setter.Value>
      <ControlTemplate TargetType="ListBoxItem">
        <Grid Background="{TemplateBinding Background}">
          <vsm:VisualStateManager.VisualStateGroups>
            <vsm:VisualStateGroup x:Name="CommonStates">
              <vsm:VisualState x:Name="Normal" />
              <vsm:VisualState x:Name="MouseOver">
                <Storyboard>
                  <DoubleAnimation Storyboard.TargetName="fillColor" Storyboard.TargetProperty="Opacity" Duration="0" To=".35"/>
                </Storyboard>
              </vsm:VisualState>
            </vsm:VisualStateGroup>
            <vsm:VisualStateGroup x:Name="SelectionStates">
              <vsm:VisualState x:Name="Unselected" />
              <vsm:VisualState x:Name="Selected">
                <Storyboard>
                  <DoubleAnimation Storyboard.TargetName="fillColor2" Storyboard.TargetProperty="Opacity" Duration="0" To=".75"/>
                </Storyboard>
              </vsm:VisualState>
            </vsm:VisualStateGroup>
            <vsm:VisualStateGroup x:Name="FocusStates">
              <vsm:VisualState x:Name="Focused">
                <Storyboard>
                  <ObjectAnimationUsingKeyFrames Storyboard.TargetName="FocusVisualElement" Storyboard.TargetProperty="Visibility" Duration="0">
                    <DiscreteObjectKeyFrame KeyTime="0">
                      <DiscreteObjectKeyFrame.Value>
                        <Visibility>Visible</Visibility>
                      </DiscreteObjectKeyFrame.Value>
                    </DiscreteObjectKeyFrame>
                  </ObjectAnimationUsingKeyFrames>
                </Storyboard>
              </vsm:VisualState>
              <vsm:VisualState x:Name="Unfocused"/>
            </vsm:VisualStateGroup>
          </vsm:VisualStateManager.VisualStateGroups>
          <Rectangle x:Name="fillColor" Opacity="0" Fill="#FFBADDE9" IsHitTestVisible="False" RadiusX="1" RadiusY="1"/>
          <Rectangle x:Name="fillColor2" Opacity="0" Fill="#FFBADDE9" IsHitTestVisible="False" RadiusX="1" RadiusY="1"/>
          <ContentPresenter
            x:Name="contentPresenter"
            Content="{TemplateBinding Content}"
            ContentTemplate="{TemplateBinding ContentTemplate}"
            HorizontalAlignment="Left"
            Margin="{TemplateBinding Padding}"/>
          <Rectangle x:Name="FocusVisualElement" Stroke="#FF45D6FA" StrokeThickness="1" Visibility="Collapsed" RadiusX="1" RadiusY="1" />
        </Grid>
      </ControlTemplate>
    </Setter.Value>
  </Setter>
</Style>

Things get a lot more interesting looking at the ListBoxItem styles and templates. The Template makes use of the VisualStateManager, which defines a different look-and-feel for each of the various states (or combination of states) the ListBoxItem might be in. The VisualStateManager can also describe transitions between states, but this functionality is not used by ListBoxItem by default.

States are divided into VisualStateGroups. At any moment, the control may be in no more than one state from each VisualStateGroup. The internal logic of the control instructs the VisualStateManager when a state needs to be activated (e.g. MouseOver state is activated when a use moves their mouse over the ListBoxItem).

The states used by ListBoxItem are:

• Common States
  • Normal
  • MouseOver
• Selection States
  • Unselected
  • Selected
• Focus States
  • Focused
  • Unfocused

For my purposes, I want to simplify this a bit. I am only interested in two states: Selected (i.e. visible) and Unselected (i.e. invisible). I do not want any changes to occur on Normal, MouseOver, Focused or Unfocused, so I will remove the extra information in these VisualStates and remove the three Rectangles which these states manipulate. In the Selected VisualState, I am going use an ObjectAnimationUsingKeyFrames to change the Visibility property to Visible. Likewise, in the Unselected VisualState, I am going to use an ObjectAnimationUsingKeyFrames to to change the Visibility property to collapsed.

Here’s the resultant styles and templates I came up with for ListBox and ListBoxItem:

<Style x:Key="ListBoxStyle" TargetType="ListBox">
    <Setter Property="HorizontalContentAlignment" Value="Left" />
    <Setter Property="VerticalContentAlignment" Value="Top" />
    <Setter Property="IsTabStop" Value="False" />
    <Setter Property="TabNavigation" Value="Once" />
    <Setter Property="Template">
        <Setter.Value>
            <ControlTemplate TargetType="ListBox">
                <ItemsPresenter />
            </ControlTemplate>
        </Setter.Value>
    </Setter>
</Style>
<Style x:Key="ListBoxItemStyle" TargetType="ListBoxItem">
    <Setter Property="HorizontalContentAlignment" Value="Left" />
    <Setter Property="VerticalContentAlignment" Value="Top" />
    <Setter Property="TabNavigation" Value="Local" />
    <Setter Property="Template">
        <Setter.Value>
            <ControlTemplate TargetType="ListBoxItem">
                <Grid Background="{TemplateBinding Background}">
                    <vsm:VisualStateManager.VisualStateGroups>
                        <vsm:VisualStateGroup x:Name="CommonStates">
                            <vsm:VisualState x:Name="Normal" />
                            <vsm:VisualState x:Name="MouseOver" />
                        </vsm:VisualStateGroup>
                        <vsm:VisualStateGroup x:Name="SelectionStates">
                            <vsm:VisualState x:Name="Unselected">
                                <Storyboard>
                                    <ObjectAnimationUsingKeyFrames Storyboard.TargetName="contentPresenter" Storyboard.TargetProperty="Visibility" Duration="0">
                                        <DiscreteObjectKeyFrame KeyTime="0">
                                            <DiscreteObjectKeyFrame.Value>
                                                <Visibility>Collapsed</Visibility>
                                            </DiscreteObjectKeyFrame.Value>
                                        </DiscreteObjectKeyFrame>
                                    </ObjectAnimationUsingKeyFrames>
                                </Storyboard>
                            </vsm:VisualState>
                            <vsm:VisualState x:Name="Selected">
                                <Storyboard>
                                    <ObjectAnimationUsingKeyFrames Storyboard.TargetName="contentPresenter" Storyboard.TargetProperty="Visibility" Duration="0">
                                        <DiscreteObjectKeyFrame KeyTime="0">
                                            <DiscreteObjectKeyFrame.Value>
                                                <Visibility>Visible</Visibility>
                                            </DiscreteObjectKeyFrame.Value>
                                        </DiscreteObjectKeyFrame>
                                    </ObjectAnimationUsingKeyFrames>
                                </Storyboard>
                            </vsm:VisualState>
                        </vsm:VisualStateGroup>
                        <vsm:VisualStateGroup x:Name="FocusStates">
                            <vsm:VisualState x:Name="Focused"/>
                            <vsm:VisualState x:Name="Unfocused"/>
                        </vsm:VisualStateGroup>
                    </vsm:VisualStateManager.VisualStateGroups>
                    <ContentPresenter
                        x:Name="contentPresenter"
                        Content="{TemplateBinding Content}"
                        ContentTemplate="{TemplateBinding ContentTemplate}"/>
                </Grid>
            </ControlTemplate>
        </Setter.Value>
    </Setter>
</Style>

And Finally, the data context:

using System;
using System.ComponentModel;
using System.Windows.Controls;
 
namespace ListBoxTest
{
    public class MyDataContext : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;
 
        public MyDataContext(UserControl view)
        {
            View = view;
            PersonList = new PersonCollection().LoadDefault();
            if (PersonList.Count > 0)
            {
                PersonComboBoxSelectedIdx = 0;
            }
        }
 
        private UserControl view;
        public UserControl View
        {
            get { return view; }
            set { view = value; }
        }
 
        private PersonCollection personList;
        public PersonCollection PersonList
        {
            get { return personList; }
            set { personList = value; NotifyChange("PersonList"); }
        }
 
        private int personComboBoxSelectedIdx;
        public int PersonComboBoxSelectedIdx
        {
            get { return personComboBoxSelectedIdx; }
            set 
            { 
                personComboBoxSelectedIdx = value; 
                NotifyChange("PersonComboBoxSelectedIdx");
                if (value.Equals(-1)) return;
 
                SelectedPerson = PersonList[value];
 
                AddressesComboBoxSelectedIdx = -1;
                ComboBox cb = (ComboBox)View.FindName("comboboxAddresses");
                cb.UpdateLayout();
                AddressesComboBoxSelectedIdx = 0;
            }
        }
 
        private int addressesComboBoxSelectedIdx;
        public int AddressesComboBoxSelectedIdx
        {
            get { return addressesComboBoxSelectedIdx; }
            set { addressesComboBoxSelectedIdx = value; NotifyChange("AddressesComboBoxSelectedIdx"); }
        }
 
        private Person selectedPerson;
        public Person SelectedPerson
        {
            get { return selectedPerson; }
            set { selectedPerson = value; NotifyChange("SelectedPerson"); }
        }
 
        private void NotifyChange(string name)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(name));
            }
        }
    }
}