Brownie Points: Programming WPF

How "Cider" Saved the Day

Wed, 19 Dec 2007 21:18:03 GMT

Or "My New Favorite Feature of the WPF Designer"

So I'm giving a quick presentation of my favorite new feature in VS 2008 at the Wisconsin .NET User Group Installfest, and because I hadn't actually prepared for the presentation in advance, Murphy's Law is in full effect. My normally snappy computer is crawling through the simplest of tasks (because I'm on battery power save mode). I'm floundering here and want to hurry and finish the demonstration (the "Cider" WPF designer). So now I'm standing in a pool of my sweat, I can't even see because the saline is dripping into my eyes. And I have to remember the syntax for importing a CLR namespace. I look to a familiar face "Quick what's the syntax for importing an assembly for reference in XAML?" Travis looks back at me with a blank stare. So I start typing hoping that something will pop in my head when I see:

At that very moment, I felt that Team Cider had put this feature in there for this very situation. I stated emphatically...well there you have my new favorite feature!

Overall the meeting was great. The turnout was HUGE. We had an assembly hall filled with people ready to install VS2008 (Professional this time as opposed to the 2005 launch when they gave out Standard). I forgot my full camera and for some reason, I can't email the pictures from my phone so I'll refer you to Larry Clarkin.

Hands down the best mini demo in my eyes was the demonstration of the code metrics capabilities of the VS 2008 Team Editions, the presenter of that feature won a copy of SceneIT! for the Xbox 360. Brennan won an 8 GB Zune for his presentation. There were a ton of toys donated in exchange for a raffle ticket. The winner got an Xbox 360 Elite with Halo 3 Limited Edition (not Legendary). And the food spread was fantastic. Especially the nacho toppings...chili and queso dip poured over tortillas is delicious! Overall, it looks like everyone enjoyed themselves. At the very least they got a free copy of VS 2008 Pro.

Silverlight 2.0 AKA Heaven on Earth

Fri, 30 Nov 2007 02:33:37 GMT

From Scott Guthrie's announcement:

WPF UI Framework: The current Silverlight Alpha release only includes basic controls support and a managed API for UI drawing. The next public Silverlight preview will add support for the higher level features of the WPF UI framework. These include: the extensible control framework model, layout manager support, two-way data-binding support, and control template and skinning support. The WPF UI Framework features in Silverlight will be a compatible subset of the WPF UI Framework features in last week's .NET Framework 3.5 release.

I figured that Silverlight would get better by the time of release, so this doesn't surprise me much. But I see more bullet points that attract my eye. Reading further:

Rich Controls: Silverlight will deliver a rich set of controls that make building Rich Internet Applications much easier. The next Silverlight preview release will add support for core form controls (textbox, checkbox, radiobutton, etc), built-in layout management controls (StackPanel, Grid, etc), common functionality controls (TabControl, Slider, ScrollViewer, ProgressBar, etc) and data manipulation controls (DataGrid, etc).

I'll refrain from sullying your screen with the filth that spewed out of my mouth when I read this (ESPECIALLY the bit about the built in DataGrid); but it was pretty much a recreation of the scene in Boondock Saints when Roc discovered that the McManus brothers had killed a room full of Russian Mafiosi (just discovered that word is the plural of Mafioso thanks to Live Writer). Back on subject, this is nothing short of amazing news! Let's not forget the fact that this release will run on Macs and Linux. Add in the networking APIs and BCL support (including LINQ) and you have a compelling development platform. Excluding the WPF 3D library, Silverlight 2.0 will essentially live up to the original Silverlight codename and be WPF Everywhere.

Oh here was the killer! Silverlight 2.0 will go into Beta soon with Go Live license!

Scott's post has some stuff in there about ASP.NET and Ajax and stuff...but I wasn't really listening to all that. It sounds good and all but not half as thrilling as the Silverlight news. Adobe who?

Blendables

Wed, 12 Sep 2007 23:18:41 GMT

I haven't posted about this yet in my blog because I assumed everyone involved with WPF development already knew about it. IdentityMine is creating a set of utilities for WPF called Blendables. Basically, the focus of Blendables is to provide additional functionality for WPF that is accessible through XAML. One cool example is the Drag-and-drop implemented through an attached property. (Looks like someone finally took my advice on using attached properties to extend functionality).

Blendables is very similar to what my initial vision of the WPF Toolbelt. A library that exposes more of the WPF framework directly to XAML with minimum code-behind. It's great to see the third party support really taking off for WPF.

While you're at the Blendables website, they are having a contest for people to showcase what Blendables has allowed them to do. Top prize is a 360 Elite. I won't have time to submit a proper entry...I'm busy with other things.

Wow...Just Wow

Sun, 24 Jun 2007 00:28:16 GMT

Not to be topped by the incredible vista desktop in Silverlight, a new software shop has released a set of tools that apparently reproduce a vast number of Winforms controls in Silverlight. It's somewhat hard to explain so just look at this. Note in particular the friggin' WINFORMS DESIGNER clone. Again...WOW! By the way, their tool also supports flash and has a free edition (that's missing some "advanced" controls...like a data grid), and a Professional Edition.

Definitely a way to increase your beta radiation levels.

Acropolis

Mon, 11 Jun 2007 17:02:36 GMT

If you remember, I spoke a bit about providing a rich designer for Business Analysts to define the flow of an application. It looks like Acropolis will go a long way toward realizing that dream. If you look at Glenn Block's synopsis, you'll see that it basically describes what I was talking about to a tee. Now I know why Rob's only comment about the Domain Tree concept was "very interesting". He knew what was coming.

I for one am excited!

Improving the Combobox

Sat, 02 Jun 2007 21:24:34 GMT

If anyone has tried loading a large number of items into a ComboBox...you've probably run into a long pause as the ComboBox renders an Element for each......and.....every....object....in....your....itemssource. You might have even resorted to using a ListBox instead even though it doesn't quite fit in your UI.

Fear not my fellow WPF'ers because I have found the solution to your pain. ComboBox derives from ItemsControl and as such, has a ItemsPanel property of type ItemsPanelTemplate.

<ItemsPanelTemplate x:Key="Template_ComboPanel"> 
   <VirtualizingStackPanel IsVirtualizing="True"/> 
</ItemsPanelTemplate>

If you set the ItemsPanelTemplate to use a VirtualizingStackPanel, the ComboBox will virtualize and you will have a much more responsive ComboBox. Even better, setup a Style for all ComboBoxes in your app and set the ItemsPanel to be that IPT. You'll be a much happier camper. My Combobox holding 5000 objects used to take around 5-10 seconds to show the popup. Now it pops up instantly.

MVC and WPF

Fri, 25 May 2007 17:56:07 GMT

So I am acutely aware that there is some confusion in the world about just what MVC is. I thought the paradigm I have been using for WPF would be considered MVC but after further research, I learned that while it is technically MVC, it is not what will first come to mind when you hear MVC. What I have been doing is making the View totally dumb. The only "knowledge" it has of the Model is imparted to it through databindings against properties exposed to it through my Controller. With "Pure" MVC, the View has a knowledge of the Model and can even act on it directly in some cases.

Doing a little more digging, I thought that I had found a name to the design pattern I have been using: Passive View. Martin Fowler's definition of the Passive View definitely fits the bill for what I do:

A screen and components with all application specific behavior extracted into a controller so that the widgets have their state controlled entirely by controller.

Martin's description of the passive view says that it's primary benefit is that it makes your application more testable. I definitely have seen that benefit. I also have noticed that my code is more flexible to change when using this design.

However, I must point out that my Controller doesn't actively update the view. It exposes properties that the View binds against. I also couple my MVC with the Command pattern (WPF really lends itself to the Command pattern seeing that it has the ICommand interface and certain UI elements have Command properties on them). All of my Controllers have a command that they expose for binding by the View, you could implement INotifyPropertyChanged, but I have been using Dependency Properties to handle all of those nuances.

Here is an example of how I would code a UI to all a user to search for an order in a customer service application. First we have the command OrderSearch (it might be an extension to a base Search Command or it might be the rSearch command with a Parameter SearchRequest that has an SearchType property (either way there will be an SearchRequest parameter). In this instance, my controller would also expose properties such as AvailableSearchFields, SelectedSearchField, SelectedSearchValue, and Results.

The View (in this case a UserControl subclass) would have its DataContext set to an instance of the Controller. There would be a ComboBox with its ItemsSource="{Binding AvailableSearchFields}" and SelectedItem="{Binding SelectedSearchField}". There is also a TextBox with its Text="{Binding SelectedSearchValue}" and a Button Command="{Binding Command}".

The only code behind required is the constructor which creates the controller and sets the control's datacontext to the controller. (And that's actually handled in the base class of the UserControl).

As you can see, there is NO logic in the UserControl, it only binds to (or observes) the Controller. Also, the Controller has no logic that deals with the UserControl directly...it only exposes properties, and performs logic in response to values being set.

The more I think about this pattern, the less it seems that it exactly matches Passive View, because Passive View implies that the Controller actually performs actions on the View. Again, my controller has no knowledge whatsoever of the view. It is not "Pure" MVC either because the View has no knowledge of the Model...I think this does follow the pattern that Dan Crevier described with Model - View - ViewModel. After going back and reading his blog further, this is exactly what this pattern is. I must have subconciously followed it. Anyway, I guess that this is just confirmation that it is definitely a pattern that works.

Using this pattern, my code is orders of magnitude more flexible and testable than using the code behind to drive the UI. I would also argue that it lends itself toward an SOA approach because of the Commands that are used to drive actions. In theory the same controller could be used to expose functionality to a website or to a Winforms UI. In order to do that, we'd probably want to move away from using DependencyProperties and instead implement INotifyPropertyChanged. Also we'd want to move from the WPF specific Command and create a Converter from our custom Command to WPF's ICommand.

While I was putting my thoughts together on this posting, Paul Stovell again one upped me and posted his thoughts on "Binding Oriented Programming". He is more or less following the same pattern I use for WPF development.

Technorati tags: WPF, MVC, Patterns

Low-Level Graphic Manipulation

Tue, 22 May 2007 22:33:42 GMT

A while ago, I participated in a discussion in the forums about creating a webcam solution in WPF. My suggestion was to use the BitmapSource API to update a bitmap source dependency property with the buffer from a custom directshow filter.

The problem with that solution is that it involves a buffer copy rather than just updating a reference to point to the new buffer. A relatively new voice in the WPF Forums, Jeremiah Morrill, took the time to learn the WIC enough to get the raw buffer pointer in a BitmapSource and redirect it to look at another buffer. Here's his blog about it.

More Attached Goodness

Thu, 10 May 2007 22:00:58 GMT

Here's the code, read on for the explanation.

So hopefully my last series on enabling MultiSelect checkboxes with attached properties reinforced the idea that the WPF team has been trying to bring home: subclassing a control should be used in extreme circumstances, because most enhancements can be done using Styles, Templates, and as I just showed Attached Properties. Here's yet another trick that we're using in a custom project.

For some reason the ATC team didn't provide an IsSortable property on the GridView...all though they did show how simple it is to add sorting to a gridview using code behind. Well you know me, I like simple. So I created an Attached Property that uses the ~~Plover~~ Remora Pattern to add sorting to a ListView (with a Gridview as its View) without any code-behind (other than the code that's in the attached property). The final XAML to use this functionality is as simple as this:

<ListView
  Util:WPFUtils.IsGridSortable="True"
  Width="Auto"
  Height="Auto"

  ItemsSource="{Binding MyItems}"
  SelectionMode="Multiple"
  Margin="5">
    <ListView.View>
      <GridView>
         <GridViewColumn Header="Name" DisplayMemberBinding="{Binding Name}"/>
         <GridViewColumn Header="Department" DisplayMemberBinding="{Binding Department}"/>

Basically all you have to do to make your GridView sortable is set the attached property IsGridSortable to true and it handles the rest. Since we already know how the Remora property works (an attached property adds functionality to the Control it's attached to during the PropertyChangedCallback) We'll cut straight to the code for our PropertyChangedCallback. (Full code will be available at the end of this posting).

private static void OnRegisterSortableGrid(DependencyObject sender,
  DependencyPropertyChangedEventArgs args)
{
  ListView grid = sender as ListView;
  if (grid != null)
  {
    RegisterSortableGridView(grid, args);
  }
}

private static void RegisterSortableGridView(ListView grid,
  DependencyPropertyChangedEventArgs args)
{
  if (args.NewValue is Boolean && (Boolean)args.NewValue)
  {
    grid.AddHandler(GridViewColumnHeader.ClickEvent, GridViewColumnHeaderClickHandler);
  }
  else
  {
    grid.RemoveHandler(GridViewColumnHeader.ClickEvent, GridViewColumnHeaderClickHandler);
  }
}

The callback basically checks if the property has been set on a listview (I am of course adding a check for if it's set on a PowerGrid) and if so calls the RegisterSortableGridView function. This function adds a custom handler for the GridViewColumnHeader.Click Event or removes it based on the value assigned to the property by the user. The handler works pretty much the same way as the ATC sample with a few differences.

if (header != null)
{
  ListSortDirection sortDirection;
  GridViewColumnHeader tmpHeader = GetLastSorted(lv);
  if (tmpHeader != null)
    tmpHeader.Column.HeaderTemplate = null;
  if (header != tmpHeader)
    sortDirection = ListSortDirection.Ascending;
  else
  {
    ListSortDirection tmpDirection = GetLastSortDirection(lv);
    if (tmpDirection == ListSortDirection.Ascending)
      sortDirection = ListSortDirection.Descending;
    else
      sortDirection = ListSortDirection.Ascending;
}

You'll see I highlighted calls to two functions GetLastSorted(lv); and GetLastSortDirection(lv). These are Getters for Read-only Attached Dependency Properties LastSorted and LastSortDirection, respectively (and the SDK said they aren't useful), that are set on the ListView during a sort operation...if this is the first sort operation of course they'll be null. The other cool feature...

switch (sortDirection)
{
  case ListSortDirection.Ascending: resourceTemplateName = "HeaderTemplateSortAsc"; break;
  case ListSortDirection.Descending: resourceTemplateName = "HeaderTemplateSortDesc"; break;
}
DataTemplate tmpTemplate = lv.TryFindResource(resourceTemplateName) as DataTemplate;
if (tmpTemplate != null)
{
  header.Column.HeaderTemplate = tmpTemplate;
}

If the user has declared HeaderTemplateSortAsc and/or HeaderTemplateSortDesc in their resource tree, it will be set on the GridViewColumnHeader. Today's upload only includes the cs file for the WPFUtils class. I'll pull it out of our main app and into it's own project later.

Again, this shows that WPF Controls can be customized without subclassing them. And without codebehind for the UI of the code cluttering your business logic code. Next time, I want to talk about MVC with WPF.

Technorati tags: WPF, Attached Properties, Code Sample, XAML, WPF Grid

Season Finale

Wed, 09 May 2007 15:34:05 GMT

When we got to yesterday's cliffhanger, we had all we needed to allow a developer to wire up a group of checkboxes to be checked or unchecked in response to the status of a single "Check/Uncheck All" checkbox with no code-behind. But the Markup to take advantage of it was ugly...well I never showed the markup to take advantage but believe me it was ugly.

In order to save my fellow WPF developers from Carpal Tunnel Syndrome, I created a markup extension that would enable developers to create a MultiSelectionTarget using Attribute Syntax (similar to declaring a Binding and all that other fun stuff). As I hinted to earlier, creating a Markup Extension is not as scary as it sounds at first. You extend the MarkupExtension class; expose properties that your Markup Extension needs to properly do its job; and override the ProvideValue function to return what the user of your Markup Extension expects (in this case a MultiSelectionTarget). Here it is in all it's glory:

   public class MultiSelectionTargetExtension : MarkupExtension
    {
        private String path;
        private MultiSelectionSource source;

        public String Path
        {
            get { return path; }
            set { path = value; }
        }

        public MultiSelectionSource Source
        {
            get { return source; }
            set { source = value; }
        }

        public override object ProvideValue(IServiceProvider serviceProvider)
        {
            if (source != null && !String.IsNullOrEmpty(path))
            {
                return new MultiSelectionTarget(source, path);
            }
            return null;
        }
    }

See, piece of cake right. Any former Java developers who created JSP Tags before will be very comfortable with this convention. I'm sure ASP.Net offers similar functionality...but I'm not an ASP.Net developer. Anyway, all of this gives us a very straightforward, all XAML method to check a group of checkboxes at once...

<Window x:Class="SelectAllDemo.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="clr-namespace:SelectAllDemo" 
    Title="SelectAllDemo" Height="300" Width="300"
    >
  <Window.Resources>
    <local:MultiSelectionSource x:Key="SelectionSource"/>
  </< span>Window.Resources>
  <StackPanel>
    <CheckBox IsChecked="{Binding Source={StaticResource SelectionSource}, Path=IsSelected}"
              FontWeight="Bold">Select All</< span>CheckBox>
    <CheckBox local:PowerSelector.MultiSelectorTarget=
                "{local:MultiSelectionTarget Source={StaticResource SelectionSource},
                Path=IsChecked}">
      Check me 1
    </< span>CheckBox>
    <CheckBox local:PowerSelector.MultiSelectorTarget=
                "{local:MultiSelectionTarget Source={StaticResource SelectionSource},
                Path=IsChecked}">
      Check me 2
    </< span>CheckBox>
  </< span>StackPanel>
</< span>Window>

So there you have it. Attached Properties, Multibindings, and MarkupExtensions have come together in harmony to enable multi selection in pure XAML. Further refactoring that I can do with the PowerSelector include making it work with comboboxes as well as checkboxes. This util is going into the WPF Toolbelt, but you can download the sample now.

Up next...using attached properties to make a standard GridView sortable.

Previously on Brownie Points...

Tue, 08 May 2007 18:24:34 GMT

"Chloe, in order to prevent the suspected terrorist from escaping, we need the ability to check multiple CheckBoxes at once in our WPF application."

"I'm looking at the Brownie Points blog now, Jack. Hopefully he'll post the rest of the solution in time. It would take too long to code it by hand. The other solution using an AttachedProperty works but it results in an iterative search through the Visual Tree, from the looks of it, Brownie takes a different approach by creating bindings from a MultiSelectionSource to each checkbox. If he puts it up in time, we can prevent Anwar Shakur from escaping."

"Chloe, why do you always explain information in detail as if I don't know already what you're talking about?"

"I don't know, Jack, I think the writers needed some way to help the viewers have a quick update of what's going on, so they created me as a person with absolutely no social skills but always in the know so that I could ask the dumb questions that the viewer would know if they had watched last week's show."

The following takes place between 12:00 PM and 1:00 PM

Where were we? Let's look at our Scenario:

In our XAML we declare a MultiSelectionSource in the Window/UserControl/Listbox.Resources.
The MultiSelectionSource holds a List that it uses to track bindings with MultiSelectionTargets
We declare MultiSelectionTargets on our checkboxes that point back to our MultiSelectionSource
The Bindings are generated and added to the MultiSelectionSource, allowing it to (un)check a group of checkboxes at once

1 and 2 are both clear, we need to enable 3 and 4.

Let's declare an Attached Property that is a MultiSelectionTarget. It might be confusing on the MultiSelectionTarget or MultiSelectionSource class, so let's make a utility class, PowerSelector, to hold the property. First we declare the property

    public static class PowerSelector
    { 
        public static readonly DependencyProperty MultiSelectorTargetProperty = 
            DependencyProperty.RegisterAttached( 
                "MultiSelectorTarget", 
                typeof(MultiSelectionTarget), 
                typeof(PowerSelector), 
                new PropertyMetadata(new PropertyChangedCallback(TargetAdded))); 

        public static MultiSelectionTarget GetMultiSelectorTarget(DependencyObject obj) 
        { 
            return (MultiSelectionTarget)obj.GetValue(MultiSelectorTargetProperty); 
        } 


        public static void SetMultiSelectorTarget(DependencyObject obj, 
          MultiSelectionTarget value) 
        { 
            obj.SetValue(MultiSelectorTargetProperty, value); 
        }  

It's a very non-assuming Attached Property, except it has a PropertyChangedCallback. It's time for our Plover bird to earn its keep

        private static void TargetAdded(DependencyObject sender, 
          DependencyPropertyChangedEventArgs e) 
        { 
            MultiSelectionTarget tmpTarget = e.NewValue as MultiSelectionTarget; 
            if (tmpTarget != null) 
            { 
                Binding tmpbinding = new Binding(tmpTarget.Path); 
                tmpbinding.Source = sender; 
                tmpbinding.Mode = BindingMode.TwoWay; 
                tmpTarget.Source.AddBinding(tmpbinding); 
            } 
        }

So it's quite simple...when the PowerSelector.MultiSelectorTarget property (of type MultiSelectionTarget) is set on a DependencyObject, the handler creates a Binding with the sender as the Source and the MultiSelectionTarget.Path as the path. The Binding is given a BindingMode of TwoWay, and we call AddBinding on the MultiSelectionSource passing the new Binding we just created. Soo...I guess we should look at how AddBinding works.

        internal void AddBinding(Binding newBinding) 
        { 
            bindings.Add(newBinding); 
            MultiBinding tmpBindings = new MultiBinding(); 
            foreach (BindingBase binding in bindings) 
            { 
                tmpBindings.Bindings.Add(binding); 
            } 
            tmpBindings.Mode = BindingMode.TwoWay; 
            tmpBindings.Converter = new MultiSelectConverter(); 
            tmpBindings.ConverterParameter = this; 
            BindingOperations.SetBinding(this, MultiSelectionSource.IsSelectedProperty,
              tmpBindings); 
        } 

        private class MultiSelectConverter : IMultiValueConverter 
        { 


            public object Convert(object[] values, Type targetType, object parameter,
              System.Globalization.CultureInfo culture) 
            { 
                MultiSelectionSource source = (MultiSelectionSource)parameter; 
                Boolean tmpBool = (Boolean)values[0];
                if (values.Length == 1) 
                    return tmpBool; 
                else 
                    for (int i = 1; i < values.Length; i++) 
                    { 
                        if ((bool)values[i] != tmpBool) 
                            return source.IsSelected; 
                    } 
                return tmpBool; 
            } 


            public object[] ConvertBack(object value, Type[] targetTypes, object parameter,
              System.Globalization.CultureInfo culture) 
            { 
                Boolean tmpVal; 
                try 
                { 
                    tmpVal = (bool)value; 
                } 
                catch (Exception e) 
                { 
                    throw new ArgumentException(
                      "This method expects a boolean as its first parameter", "value", e); 
                } 
                Object[] retVal = new Object[targetTypes.Length]; 
                for (int i = 0; i < retVal.Length; i++) 
                { 
                    retVal[i] = tmpVal; 
                } 
                return retVal; 
            } 
        } 
    }

Remember bindings is a private IList that MultiSelectionSource declared so the Binding created by the AddTarget handler is added to that list. A new MultiBinding is created and all of the bindings stored in ...umm... bindings are added to it. The MultiBinding is set to TwoWay and a MultiSelectConverter is created and assigned as its converter. (A MultiBinding REQUIRES an IMultivalueConverter to be set on it.) The MultiSelectConverter has pretty simple logic ConvertBack sets all of the Sources to the new Value of the Target...In this case the Sources are MultiSelectionTargets and the target is the MultiSelectionSource. Convert sets the MultiSelectionSource only if all the MultiSelectionTargets agree, otherwise it keeps the same value.

Finally, in order to simplify life for the end user -- in this case the developer -- I created a markup extension that allows you to create a MultiSelectionTarget using attribute syntax rather than requiring property syntax....which is much more verbose. Markup Extensions aren't as frightening to develop as they first sound. Basically you extend MarkupExtension, put properties on your class and override the ProvideValue method. It's much easier to visualize in code...But I'm out of time for now. I'll wrap it all up later and make the code available for download somehow...I wish spaces allowed you to upload files.

beep...beep...beep...beep

Code Snippet

Mon, 07 May 2007 15:48:54 GMT

So it finally got to the point where I was tired enough of "enhancing" my dependency properties by hand that I felt it was worth the investment to learn how to write code snippets. The "Orcas" preview for VS2005 already comes with a few snippets to simplify declaring dependency properties and attached dependency properties (propdp and propa, respectively). But it was missing a few things...I stumbled across some enhanced snippets at notstatic.com. But it was still missing something, I needed my snippet to automatically generate the PropertyChangedCallback. So I opened up the snippet to see what I needed to do to add that enhancement.

Surprisingly enough it was quite simple. The snippet uses token substitution to place named parameters into the code. I guess it'd be easier to show you. If anyone else needs this, just save it as propdh.snippet under your %vsinstall%\VC#\Snippets\%lcid%\Visual C# directory where %vsinstall% is your installation root of VS2005 and %lcid% is your locale identifier (1033 for us english).

<?xml version="1.0" encoding="utf-8"?>
<CodeSnippets xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
  <CodeSnippet Format="1.0.0">
    <Header>
      <SnippetTypes>
        <SnippetType>Expansion</SnippetType>
      </SnippetTypes>
      <Title>Define a DependencyProperty</Title>
      <Shortcut>propdph</Shortcut>
      <Description>
        Code snippet for a property using DependencyProperty as the backing
        store and a Handler for the DependencyPropertyChanged event
      </Description>
      <Author>Mike Brown</Author>
    </Header>
    <Snippet>
      <Declarations>
        <Literal Editable="true">
          <ID>type</ID>
          <ToolTip>Property Type</ToolTip>
          <Default>int</Default>
          <Function>
          </Function>
        </Literal>
        <Literal Editable="true">
          <ID>property</ID>
          <ToolTip>Property Name</ToolTip>
          <Default>MyProperty</Default>
          <Function>
          </Function>
        </Literal>
        <Literal Editable="false">
          <ID>ownerclass</ID>
          <ToolTip>
            The owning class of this Property. Typically the class that it is
            declared in.
          </ToolTip>
          <Default>ClassNamePlaceholder</Default>
          <Function>ClassName()</Function>
        </Literal>
      </Declarations>
      <Code Language="csharp">
        <![CDATA[
 
public $type$ $property$
{
    get { return ($type$)GetValue($property$Property); }
    set { SetValue($property$Property, value); }
}
public static readonly DependencyProperty $property$Property = DependencyProperty.Register(
  "$property$", 
  typeof($type$), 
  typeof($ownerclass$), 
  new UIPropertyMetadata(default($type$), new PropertyChangedCallback(On$property$Changed)));
 
private static void On$property$Changed(DependencyObject sender, DependencyPropertyChangedEventArgs args)
{
  $ownerclass$ tmp$ownerclass$ = sender as $ownerclass$;
  if (tmp$ownerclass$!=null)
  {
    //TODO: Do what you need to do with the new value.
  }
}
$end$]]>
      </Code>
    </Snippet>
  </CodeSnippet>
</CodeSnippets>

Code Climber: Custom Controls

Thu, 08 Feb 2007 07:43:58 GMT

So a user was asking in the WPF Forums how to get a UserControl to call a method on its parent. I told him the simplest way is to use a RoutedEvent and proceeded to give a code example that showed the basics.

Charlie Calvert is doing a series that he calls Code Climber which discusses Lambdas from the bottom up. I'm sure it will be a great series when it's all done.

This post inspired me to do a Code Climber of my own. I want to cover custom controls in WPF. Of course, the MSDN library already has a great overview of WPF control authoring, I wouldn't presume to replace that documentation especially for those with a pressing deadline to learn this topic. But for those willing to take a journey with me, it could be fun.

Here is the Itinerary for our voyage:

Window/Frame
UserControl
Control
FrameworkElement

The stops follow the path from commonplace, (I.e. practically every WPF UI developer will use a Window or Frame) to the more esoteric FrameworkElement. Interestingly enough, FrameworkElement based custom controls may be MOST familiar to those used to custom control development for Winforms/GDI+, where developers are used to rendering the control directly using graphics primitives. Whereas the paradigm for developing custom controls that derive from System.Windows.Controls.Control would be most familiar for someone developing an ASP.Net server-side control.

It's a little bit past my bedtime, but look forward to seeing the first entry talking about everyone's favorite custom control: Window1.

DM-V-VM Series

Mon, 18 Dec 2006 19:54:30 GMT

Dan Crevier put a nice summary post for his Data Model - View - View Model series on his blog. I'm putting it on my blog so that I can find it more easily.

Two New Releases

Thu, 31 Aug 2006 02:23:52 GMT

Everybody with dreams of developing a video game should know by now that the beta of XNA Game Studio Express has been released today. Although this version doesn't support developing for the 360, you can get started now developing for windows and when the December release arrives, your code will port to the 360. Why are you still reading this? GO GET IT!

Arriving with a bit less fanfare was the Windows Vista August CTP on MSDN subscriber downloads. I haven't seen a matching orcas/windows sdk release for it yet, but I'm sure one will be following soon...with the pomp and circumstance due another preview of Vista. The odd thing was that I thought this was supposed to be RC1...anyway if you're an MSDN subscriber go ahead and get the August CTP.

Of course all this comes when I'm trying to design my converter for the XAML conversion contest! It's a conspiracy I tell you. C-O-N-spiracy.

Big News!!!!

Fri, 21 Jul 2006 22:08:23 GMT

I have been given the green light to turn the WPF grid control that I've been developing at work into an open source project. My hope is that it will become a full suite of controls that help WPF developers become productive just as quickly as Winforms developers. Leave a comment here if you're interested in learning more (e.g. when it's available) and/or joining the project.

Assuming codeplex ever approves my request that is