Titan

Upgrading from SQL Server Express Edition

noreply@blogger.com (Derek Lakin) — Mon, 04 Jul 2011 08:49:00 +0000

This is more of a personal note-to-self, but hopefully it will save someone else tearing their hair out!

If you already have SQL Server Express Edition installed and you decide to install a “higher” (Standard, or Enterprise) edition, then you might be surprised when you find after the installation that the complete management tools are not installed, such as SQL Server Profiler.

After much trial and error (and loss of yet more hair) I found that the following worked for me:

Run the SQL Server setup.
Go to the Maintenance option, and then perform a Feature Upgrade on the Shared Features (select <<Upgrade shared feature components only>> when you select the edition to upgrade).
Go back to setup, and then select New installation or add features to an existing installation.
During the installation, select Management Tools - Complete.
Bask in the glory of your new found management tools.

I suspect (that can’t confirm) that if you perform the feature upgrade mentioned in step 2 before you install the new edition then the Management Tools - Complete option will be available during the installation of the new edition.

Hope this helps.

Don’t Forget Your Windows Phone 7 Capabilities

noreply@blogger.com (Derek Lakin) — Fri, 21 Jan 2011 11:46:00 +0000

If you’re developing a Windows Phone 7 application and you’re being a responsible developer and cleaning up the capabilities section of your WMAppManifest.xml file^[1] and then get unexpected errors when you extend your application further (such as adding the WebBrowser control), don’t forget to rescan your capabilities to ensure they are up to date.

I just did exactly that; I added the WebBrowser control to a WP7 project and got an exception that gave the error code 80010108. I had removed the ID_CAP_WEBBROWSERCOMPONENT capability from the WMAppManifest.xml file.

Just thought I’d make a public not to myself and hope it saves someone else some searching.

^[1] For more information about the Windows Phone Capability Detection Tool and how to run it easily from within Visual Studio, check out my earlier blog post.

Customizing MessageBox on Windows Phone 7

noreply@blogger.com (Derek Lakin) — Tue, 18 Jan 2011 11:38:00 +0000

Whilst I’m really impressed with Windows Phone 7 as a smartphone operating system and even more impressed with the ease and simplicity with which developers can produce applications for this new operation system (it’s basically Silverlight 3 with a few phone-specific tweaks and additions), there are a few omissions that can make life difficult for developers. One of these omissions is in the MessageBox API, which offers the following two Show methods:

MessageBoxResult Show(string);
MessageBoxResult Show(string, string, MessageBoxButton);

The problem is that the MessageBoxButton enumeration only supports the OK and OKCancel values, which means that we’re limited to either an ok button or an ok and a cancel button. The YesNo and YesNoCancel enumeration values are not supported. I’ve just been working on a project where these additional values would have been helpful and in fact, instead of inventing a custom UI, I wanted to be able to customize the button labels, so I set about creating my own MessageBoxService class (the use of an instance class instead of static methods was mostly down to which way the wind was blowing!).

User Interface Layers

The following diagram shows the layers required on the user interface:

Basically, we need to display a semi-transparent blanking layer over the page content, and then display the message box on top of that. In order to correctly swap colors when the device theme changes there’s actually an extra layer under the message box content, too.

To all intents and purposes the XAML for the user interface (shown above) looks something like this:

   1:  <Grid Background="#7F000000" Grid.RowSpan="2">

   2:      <Grid.RowDefinitions>

   3:          <RowDefinition Height="Auto" />

   4:          <RowDefinition Height="*" />

   5:      </Grid.RowDefinitions>

   6:      <Grid Background="#7F000000">

   7:          <Grid.ColumnDefinitions>

   8:              <ColumnDefinition Width="*" />

   9:              <ColumnDefinition Width="*" />

  10:          </Grid.ColumnDefinitions>

  11:          <Grid.RowDefinitions>

  12:              <RowDefinition Height="Auto" />

  13:              <RowDefinition Height="Auto" />

  14:          </Grid.RowDefinitions>

  15:          <Grid.Projection>

  16:              <PlaneProjection />

  17:          </Grid.Projection>

  18:          <Border Background="{StaticResource PhoneForegroundBrush}"

  19:                  Grid.ColumnSpan="2"

  20:                  Grid.RowSpan="2" />

  21:          <Border Background="#7F000000"

  22:                  Grid.ColumnSpan="2"

  23:                  Grid.RowSpan="2" />

  24:          <StackPanel Grid.ColumnSpan="2" Margin="12,0,12,12">

  25:              <TextBlock FontFamily="Segoe WP Semibold"

  26:                         FontSize="32"

  27:                         Margin="12"

  28:                         Text="Message Caption"

  29:                         TextWrapping="Wrap" />

  30:              <TextBlock FontSize="24"

  31:                         Margin="12,0,12,12"

  32:                         Text="Message Text"

  33:                         TextWrapping="Wrap" />

  34:          </StackPanel>

  35:          <Button Content="yes" Grid.Row="1" />

  36:          <Button Content="no" Grid.Column="1" Grid.Row="1"/>

  37:      </Grid>

  38:  </Grid>

In actual fact I create the user interface in code so that I can update the number of columns and the column span of the elements according to the number of buttons being displayed. One of the other things that seemed odd to me with the framework MessageBox.Show methods is that if you only display an ok button, that button only takes up half of the width of the message box, so I fixed that in my MessageBoxService so that when there is only one button, it stretches to fit.

Adding the Message Box to the Current Page

The next part in the process is to actually inject the user interface for our custom message box into the current page. To achieve this, I keep use two properties: one to get the PhoneApplicationFrame that holds the application content, and another that is updated every time the message box is shown which identifies the current PhoneApplicationPage, as shown below.

   1:  public PhoneApplicationFrame RootFrame

   2:  {

   3:      get

   4:      {

   5:          if (null == this._frame)

   6:          {

   7:              this._frame = Application.Current.RootVisual as PhoneApplicationFrame;

   8:          }

9:

  10:          return this._frame;

  11:      }

  12:  }

   1:  public PhoneApplicationPage CurrentPage

   2:  {

   3:      get

   4:      {

   5:          if ((null == this._page) &&

   6:              (null != this.RootFrame))

   7:          {

   8:              this._page = this

   9:                  .RootFrame

  10:                  .GetVisualDescendants()

  11:                  .OfType<PhoneApplicationPage>()

  12:                  .FirstOrDefault();

  13:              if (null == this._page)

  14:              {

  15:                  this._page = this.RootFrame.Content as PhoneApplicationPage;

  16:              }

  17:          }

18:

  19:          return this._page;

  20:      }

  21:  }

NOTE: The GetVisualDescendants method is an extension method that is included in the code download.

Once I’ve got the current page, I then find the first visual descendant of the page that is a Panel, which is invariably a Grid because of the templates that Visual Studio/Expression Blend provides.

   1:  private Panel FindRootVisual()

   2:  {

   3:      if (null != this.CurrentPage)

   4:      {

   5:          // Return the first Panel element.

   6:          return this

   7:              .CurrentPage

   8:              .GetVisualDescendants()

   9:              .OfType<Panel>()

  10:              .FirstOrDefault();

  11:      }

12:

  13:      return null;

  14:  }

If it is a Grid, I set the Grid.ColumnSpan and Grid.RowSpan attached properties on my own root element (for the message box) so that it completely covers the page content.

   1:  // Make sure that our grid spans all rows and columns of it's parent, if the

   2:  // parent is a Grid.

   3:  if (rootVisual is Grid)

   4:  {

   5:      var parent = (Grid)rootVisual;

   6:      int columnCount = parent.ColumnDefinitions.Count;

   7:      if (columnCount > 0)

   8:      {

   9:          this._rootElement.SetValue(

  10:              Grid.ColumnSpanProperty,

  11:              columnCount);

  12:      }

13:

  14:      int rowCount = parent.RowDefinitions.Count;

  15:      if (rowCount > 0)

  16:      {

  17:          this._rootElement.SetValue(

  18:              Grid.RowSpanProperty,

  19:              rowCount);

  20:      }

  21:  }

Once we’ve done all that, it’s simply a matter of adding the root element of the message box user interface to the Children collection of the Panel element.

Animating the Message Box

The normal MessageBox animates in and out using an animation that appears to make the content “swivel” around it’s horizontal center. To be as consistent as possible I wanted to do the same thing. Fortunately, the awesome Kevin Marshal has already done the hard work in this respect in his WP7 – Page Transitions Sample blog post. So, I added two Storyboards that are initialised in the constructor: one for the show animation and one for the hide animation. To the naked eye, the animations are virtually indistinguishable from the normal MessageBox.

Once the message box user interface is added to the current page, I update the show Storyboard so that each part targets the correct element, and then start the animation on the first layout.

   1:  // Update and start the storyboard to show the message box.

   2:  foreach (var timeline in this._showStoryboard.Children)

   3:  {

   4:      Storyboard.SetTarget(timeline, this._mbsRoot);

   5:  }

6:

   7:  // Once the elements are ready, start the storyboard to show them.

   8:  this._mbsRoot.InvokeOnLayoutUpdated(() =>

   9:  {

  10:      this._showStoryboard.Begin();

  11:  });

NOTE: The InvokeLayoutUpdated method is another extension method that is included in the code download.

Handling the Back Button

The next hurdle to overcome is handling the back button. With a page loaded, pressing the back button would normally navigate backwards through the page stack, but when a message box is displayed pressing the back button should dismiss the message box instead.

Fortunately, I’ve already got a reference to the current page, so I use this to hook the BackKeyPress event. In the handler I check to make sure that the message box is open, then cancel the back key press and close the message box.

   1:  private void OnBackKeyPress(object sender, CancelEventArgs args)

   2:  {

   3:      if (true == this.IsOpen)

   4:      {

   5:          args.Cancel = true;

   6:          this.Close();

   7:      }

   8:  }

Closing the Message Box

Closing the message box is a fairly simple process that is initiated by setting the Result property. The Result property is a MessageBoxResult property and in the setter I call the Close method. The close method does a bit of tidying up, makes sure that both storyboards are stopped, updates the target for the hide animation, and then starts the hide animation. Once the hide animation has completed I raise the Closed event. Each of the buttons has it’s Click event wired up to an event handler that sets the Result property to the appropriate value.

   1:  private void Close()

   2:  {

   3:      this.IsOpen = false;

   4:      this._showStoryboard.Stop();

   5:      this._hideStoryboard.Stop();

   6:      foreach (var timeline in this._hideStoryboard.Children)

   7:      {

   8:          Storyboard.SetTarget(timeline, this._mbsRoot);

   9:      }

10:

  11:      this._hideStoryboard.Completed += this.HideStoryboard_Complete;

  12:      this._hideStoryboard.Begin();

  13:  }

14:

15:

  16:  private void HideStoryboard_Complete(object sender, EventArgs e)

  17:  {

  18:      if (null != this._hideStoryboard)

  19:      {

  20:          this._hideStoryboard.Completed -= this.HideStoryboard_Complete;

  21:      }

22:

  23:      this.RaiseClosed();

  24:  }

Using the MessageBoxService

So far I’ve covered the major points of the MessageBoxService implementation, but not now to use it. The MessageBoxService class exposes a single Show method, a Result property, and a Closed event. You call Show, wait for the Closed event to fire, and then check the value of the Result property as the following code snippet shows.

   1:  private void MessageBoxService_Click(object sender, RoutedEventArgs e)

   2:  {

   3:      this._service.Closed += this.MessageBoxService_Closed;

   4:      this._service.Show(

   5:          this._message.Text,

   6:          this._caption.Text,

   7:          MessageBoxServiceButton.YesNoCancel);

   8:  }

9:

  10:  private void MessageBoxService_Closed(object sender, EventArgs e)

  11:  {

  12:      this._service.Closed -= this.MessageBoxService_Closed;

  13:      this._result.Text = this._service.Result.ToString();

  14:  }

You can also customize the button labels (which was one of my original goals) by passing in a List<string> of button labels. When the MessageBoxService creates the buttons it checks to see if a custom label has been provided and uses that instead. The other labels are stored in a Resources file to make localization easier.

The following code example shows how to specify custom button labels. Each label is used to replace the corresponding button in the supplied MessageBoxServiceButton enumeration value. In the following example, abort corresponds to yes and the Result property will be MessageBoxResult.Yes, and retry corresponds to no and the Result property will be MessageBoxResult.No.

   1:  private void MessageBoxService_Click(object sender, RoutedEventArgs e)

   2:  {

   3:      this._service.Closed += this.MessageBoxService_Closed;

   4:      this._service.Show(

   5:          this._message.Text,

   6:          this._caption.Text,

   7:          MessageBoxServiceButton.YesNoCancel

   8:          new List<string> { "abort", "retry", "cancel" });

   9:  }

Known Issues

The standard MessageBox has better access to the operating system than us lowly developers do, so there are a couple of things that I wasn’t able to achieve in my MessageBoxService implementation:

There is no sound played when the message box is shown. The sound files that the operating system uses have not (yet?) been made publicly available, so I wasn’t able to include this. You could use your own sound, but I opted to go without for now. If you want to add your own sound, or when the Metro sound files are released, you can play a sound by using the XNA SoundEffect class, as described on MSDN.
When the system tray is visible, I’ve got no way to blank it out like the standard message box does, so the system tray remains visible. In the application I was working on, the system tray wasn’t visible, so not a big deal for me, and unlikely to be a problem more generally, but it still niggles.
Similarly, there’s no way to extend the blanker overlay over the application bar, which is provided by the operating system. As a workaround for this, the MessageBoxService class remembers whether the application bar was visible when it was shown, and then hides it. When it is closed, the application bar is shown again. Again, not an ideal solution, but better than having an enabled application bar.

Tips

A few other things I learned along the way:

If you want to use a semi-bold font weight for the default Segoe font, you need to actually change the FontFamily to Segoe WP Semibold (it’s used for the title of the message box).

The Code

You can access the code from GitHub: https://github.com/dereklakin/MessageBoxService or you can download a ZIP of the code from SkyDrive:

New Year, New Start

noreply@blogger.com (Derek Lakin) — Thu, 28 Oct 2010 18:06:00 +0000

Today is the first day of Microsoft’s Professional Developer Conference (PDC), which is being hosted on Microsoft’s Campus in Seattle right now as I type. I’m really excited to be here at such an exciting time for Microsoft development, even more so having just been told by Steve Balmer that we’ll all be getting our very own Windows Phone 7 device and free registration in the Windows Phone 7 Application Marketplace!

However, that’s not the reason of this post (though bragging was definitely a motivation). The other reason that I’m excited today was announced in a tweet from Robby Ingebretsen that no doubt got lost in amongst all the PDC tweets. He and I are really pleased to announce that at the start of 2011 I will be an employee of Pixel Lab.

This is a fantastic opportunity for me and I’m really pleased to be able turn what has already been a successful contract relationship into a permanent fixture. Robby, Kevin Moore, and Adam Kinney have been working on some great projects and I’ve worked on a few recently including Windows Phone 7 applications, Silverlight projects such as the JetPack theme and the HALO web site, and much more. 2011 is going to be a great year and I can’t for it to get here!

Checking Your WP7 Application Capabilities

noreply@blogger.com (Derek Lakin) — Fri, 22 Oct 2010 00:57:00 +0000

If you’re doing Windows Phone 7 application development then part of the submission process replaces the capabilities in the manifest file with those capabilities that it actually requires. To potentially save yourself some time and testing effort, you should make sure that you fully test your application using the correct set of capabilities before it gets to the submission process. This step just got a little easier in the Windows Phone Developer Tools October 2010 Update, which includes the Windows Phone Capability Detection Tool.
You use the Capability Detection Tool against your application XAP file to verify which capabilities you actually need so that you can update your manifest accordingly. As the above MSDN article explains, it’s a command line tool which you use like this:
CapabilityDetection.exe Rules.xml [Path to bin folder]

To make my life a little easier I turned this into an External Tool in Visual Studio. Just set the Command to C:\Program Files (x86)\Microsoft SDKs\Windows Phone\v7.0\Tools\CapDetect\CapabilityDetection.exe, the Arguments to Rules.xml $(BinDir), and the InitialDirectory to C:\Program Files (x86)\Microsoft SDKs\Windows Phone\v7.0\Tools\CapDetect\. You should also check the Use Output Window checkbox.
The settings and example output are shown in the following picture.

Update

Note: Under some circumstances (such as local instantiation of a Uri) the capability detection tool will report the ID_CAP_NETWORKING capability. If you really don't need this capability you can safely remove it, but you should make sure you test fully after removing it.

Aside

The October Update also includes the Windows Phone Connect Tool, which enables you to connect your phone to a PC when the Zune software is not running and debug applications that use media APIs and unspecified improvements to gesture performance when using the Bing Maps Silverlight control.

Clearing Cookies on Windows Phone 7 or How to Log Out of Facebook

noreply@blogger.com (Derek Lakin) — Tue, 14 Sep 2010 01:14:00 +0000

Like many people it seems I’ve been working on an application for Windows Phone 7 that integrates with Facebook. Now that I’m getting close to completion I was looking at the use cases that fall outside of the core area such as logging out of Facebook to enable the user to use different credentials. Traditionally, you’d get the cookies for the relevant Facebook URLs and clear them out. Many people on the forums appear to have hit the same problem that I did in that there is no direct API in Windows Phone 7 to access cookies for the WebBrowser control. I managed to find a way round this and here’s how I did it:

Keeping Track of Cookies

There’s no direct API to get the cookies for the WebBrowser control, but you can get access to the cookies for a specific web request by providing a value for the CookieContainer property:

   1:  private HttpWebRequest _webRequest;

   2:  private CookieContainer _cookieContainer = new CookieContainer();

   3:  ...

   4:  this._webRequest = (HttpWebRequest)HttpWebRequest.Create(uri);

   5:  this._webRequest.CookieContainer = this._cookieContainer;

What you’ll notice here is that I’m creating an HttpWebRequest and an associated CookieContainer and passing that CookieContainer to the web request. What you’ll need to do is to keep hold of this web request for the lifetime of your application, or at the very least keep hold of the last web request that you used to access Facebook (depending on how busy your application is and what you’re doing with web requests. I managed to change my application code to use a single web request for the whole application lifetime). Then you can use the CookieContainer instance to find the relevant cookies.

Finding and Clearing Facebook’s Cookies

In order to track down Facebook’s cookies so that you can clear them out you need to ask the CookieContainer for the cookies that match a certain URL. I found that asking for https://login.facebook.com/login.php was all I needed to do, but your mileage may vary. I use this code in my WebClientHelper class (which holds my web request) to clear cookies for a specified URL:

   1:  public void ClearCookies(Uri uri)

   2:  {

   3:      var cookies = this._cookieContainer.GetCookies(uri);

   4:      foreach (Cookie cookie in cookies)

   5:      {

   6:          cookie.Discard = true;

   7:          cookie.Expired = true;

   8:      }

   9:  }

I found that setting both the Discard and Expired properties to true was sufficient to clear the cookies. It may well be that either one of them on their own is adequate; I haven’t had the opportunity to verify that.

So, the code that calls this method looks like this:

   1:  private static readonly Uri FacebookCookieUri = new Uri("https://login.facebook.com/login.php");

   2:  ...

   3:  this._helper.ClearCookies(FacebookCookieUri);

If you then send the WebBrowser control to the login URL for Facebook as you would normally, then you should find that the cookies are cleared and the user is presented with the login dialog as usual.

I hope this helps.

Application.DoEvents in WPF

noreply@blogger.com (Derek Lakin) — Mon, 07 Dec 2009 15:03:00 +0000

Recently I’ve been trying to make some thumbnail generation code synchronous. I’m trying to grab the first frame from a Shockwave Flash (SWF) or Flash Video (FLV) file and save it as a thumbnail, but in order to do that I needed to create a Window to host an ActiveX control that renders the Flash file so that I can then use a RenderTargetBitmap to grab a frame.

The code sits inside a handler for the ContentRendered event of the Window and is initialised something like this:

   1:  public bool CreateThumbnail(string sourcePath, string targetPath)

   2:  {

   3:      // NOTE: Loads of code missed for brevity.

   4:      ManualResetEvent waitHandle = new ManualResetEvent(false);

   5:      bool generated = false;

6:

   7:      var win = new Window()

   8:      {

   9:          AllowsTransparency = true,

  10:          Opacity = 0.0,

  11:          Left = 0,

  12:          Top = 0,

  13:          SizeToContent = SizeToContent.WidthAndHeight,

  14:          ShowInTaskbar = false,

  15:          WindowStyle = WindowStyle.None

  16:      };

  17:      win.ContentRendered += (sender, e) =>

  18:      {

  19:          // Use RenderTargetBitmap to get the frame and save it.

  20:          generated = true;

  21:          waitHandle.Set();

  22:      }

23:

  24:      win.Show();

  25:      waitHandle.WaitOne(5000);

  26:      return generated;

  27:  }

The problem is that the ContentRendered event doesn’t fire until after the WaitOne call on the ManualResetEvent, effectively meaning that thumbnail generation fails all the time. Basically, the UI thread is blocked waiting for the wait handle to be signalled, so it doesn’t get round to rendering the Window until after this method has called.

For VB programmers out there, you may be thinking that you simply call Application.DoEvents() to free up the message loop and unfortunately WPF doesn’t provide the same API. However, there is a way to do this in WPF. By pushing a nested message loop we can cause this nested message loop to be processed immediately, allowing the Window’s content to be rendered and our thumbnail to be generated. I wouldn’t recommend using nested message loops and neither would many other people, but in this case it works for me. All I needed to do was to add the following line of code between the win.Show() call and the waitHandle.WaitOne(5000) call above:

Application.Current.Dispatcher.Invoke(
    DispatcherPriority.Background, 
    new ThreadStart(delegate { }));

Thanks to Zhou Young’s post for the simplest implementation of DoEvents in WPF that I’ve seen. As you can see, he’s put it in his Application class, but personally I think that’s just encouraging you to use this approach and in most cases I think there’s a better solution for you.

Installing Office 2010 Beta – Part 2

noreply@blogger.com (Derek Lakin) — Fri, 04 Dec 2009 10:46:00 +0000

After eventually managing to get Office 2010 Beta to install as described in my previous post, I then had problems with the actual applications themselves such that every time I tried to run one of the applications it would go through a lengthy configuration process, so I posted some feedback on the Microsoft Connect site and have been dealing with Sean Francis at Microsoft since to try and resolve my problems.

Uninstalling Office

One thing that I have learnt along the way is that my previous suggestion of using the Windows Installer CleanUp Utility is a bit outdated. Office 2007 and above no longer uses a single MSI for the installation, instead they use multiple MSIs and in actual fact, the Installer CleanUp Utility doesn’t delete any files, it just removes registry entries.

I don’t know if there’s an officially supported approach to cleaning up previous versions of Office, but Sean was good enough to attach a couple of VB scripts to the feedback item on Microsoft Connect. One of them is for cleaning Office 2007 and the other is for cleaning Office 2010 (scroll down to just above the comments to find the attached files).

Run the relevant script from a command prompt (if you have UAC enabled, make sure you open the command prompt as Administrator) and replace the text in the prompt with “ALL, OSE” (without the quotes) and then let it do it’s funky thing.

Installing Again

After successfully uninstalling Office 2007, then Office 2010, I was ready to install Office 2010 Beta again, but unfortunately my problems didn’t end here :(

My problem now was all down to registry permissions. For some bizarre reason, there were a number of registry keys that the Office installation was trying to access that simply didn’t have any permissions, hence the problem as shown in this image.

After a lot more to-ing and fro-ing with Sean, I ended up having to manually take ownership of the parent key, then add my user account with Full Control to the parent key and it’s sub-keys and then deleting the key.

(NOTE: Sean managed to work out that the key in question was: HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Installer\UserData\S-1-5-18\Components, in case you’re interested.)

After six attempts at doing this with a different problem key every time, I decided to try something slightly different; I took ownership of the Components key one level up and then added my user account with Full Control to that key and all sub-keys. Although RegEdit said that it didn’t manage it on all sub-keys, I carried on any way and thankfully the install completed successfully this time and thankfully, there were no more post-install configuration problems either!

Summary

To install Office 2010 Beta in the first place, you need to make sure you’ve purged Office 2007 and Office 2010 CTP from your system, which you should do using the scripts attached to my feedback on the Microsoft Connect site.

If your install fails because of registry permissions as described above, take ownership of the Components key, add your user account with Full Control to it and all sub-leys, then retry the installation.

Once you’ve done either or both of the above, you should be good to go.

Installing Office 2010 Beta

noreply@blogger.com (Derek Lakin) — Wed, 18 Nov 2009 08:25:00 +0000

Update

If you’re having trouble removing Office 2007/2010 CTP, don’t use the Windows Installer CleanUp Utility. See my subsequent post for updated information.

The beta release of Office 2010 was released yesterday on MSDN, Technet, and Connect, so like a good geek I rushed out and downloaded it. First things first, if you have the Community Technology Preview installed, you’ll need to uninstall it, which I did. However, after doing that and rebooting I still got the following error message:

As we had already established “Microsoft Office 2010 does not support upgrading from a pre-release version of Microsoft Office 2010.” so I was at a bit of a loss as to the cause of the problem.

To cut a long (and stressful) story short, I downloaded the Windows Installer CleanUp Utility and managed to locate and uninstall a couple of stray Office 2007 components that still existed but weren’t listed in Control Panel and voila! It worked. Hopefully this post will save a few other people some time and hassle.

P.S.

I had the same problem with the 64-bit version of Office 2010 Beta, but decided against installing, because it won’t work with 32-bit plug-ins and I think it will be a while before any of the applications that I have that integrate with office produce a 64-bit version of their plug-ins.

Product Activation Failed

After successfully getting Office 2010 installed (watch out for the Junk Email Filter Update in the Windows Installer CleanUp Utility list) the next problem was that I got a “Product Activation Failed” message for all of the applications. The solution to this problem is thankfully much simpler: Go to Control Panel and choose to “Change” the application (rather than Uninstall). In the dialog box, select “Enter a Product Key” and provide the key that you have (from MSDN/TechNet/Connect) and then carry on (click “Continue” until the end). Another problem solved.

Free WPF DataGrid from Xceed

noreply@blogger.com (Derek Lakin) — Thu, 11 Jun 2009 09:17:00 +0000

I just registered for the free Xceed DataGrid for WPF, and there’s only 3 days left to do it. http://xceed.com/freegrid. Get it now before it becomes the Standard Edition priced at $300 and get a free upgrade to the Standard Edition!

This work is licensed under a Creative Commons Attribution By license.

Testing Private Members in Visual Studio

noreply@blogger.com (Derek Lakin) — Wed, 10 Jun 2009 16:26:00 +0000

I’m currently working on a CommandBehaviour class to enable me to fire commands in response to arbitrary routed events on elements that don’t natively support commands, inspired by Sacha Barber’s post WPF: Attached Commands.

Whilst trying to apply some unit tests to what I’m writing I came across the age old problem of how to test things which are private by design. Under normal circumstances I would probably have made them protected and written a TestableCommandBehaviour class in the test project that inherits from CommandBehaviour and exposes the protected members that I wanted to test.

However, in this particular instance, I’d already written the code so I used the Create Unit Tests feature in Visual Studio to generate some unit tests for me to get me started. What I didn’t realise before was that when you do this, it creates a “Test Reference”, which provides you with a private accessor that you use to access the private code*.

Here’s a cut down version of the CommandBehaviour class:

   1:  namespace DerekLakin.Libraries.Presentation

   2:  {

   3:      public class CommandBehaviour

   4:      {

   5:          public static readonly DependencyProperty CommandProperty =

   6:            DependencyProperty.RegisterAttached(

   7:              "Command",

   8:              typeof(ICommand),

   9:              typeof(CommandBehaviour),

  10:              new UIPropertyMetadata(null));

11:

  12:          public static readonly DependencyProperty CommandParameterProperty =

  13:            DependencyProperty.RegisterAttached(

  14:              "CommandParameter",

  15:              typeof(object),

  16:              typeof(CommandBehaviour),

  17:              new UIPropertyMetadata(null));

18:

  19:          public static readonly DependencyProperty EventNameProperty =

  20:            DependencyProperty.RegisterAttached(

  21:              "EventName",

  22:              typeof(string),

  23:              typeof(CommandBehaviour),

  24:              new UIPropertyMetadata(string.Empty, new PropertyChangedCallback(EventNameChanged)));

25:

  26:          private static readonly DependencyProperty CommandBehaviourProperty =

  27:            DependencyProperty.RegisterAttached(

  28:              "CommandBehaviour",

  29:              typeof(CommandBehaviour),

  30:              typeof(CommandBehaviour),

  31:              new UIPropertyMetadata(null));

32:

  33:          private readonly WeakReference sourceElement;

  34:          private EventInfo eventInformation;

  35:          private Delegate targetDelegate;

36:

  37:          private CommandBehaviour()

  38:          {

  39:          }

40:

  41:          private CommandBehaviour(DependencyObject source)

  42:          {

  43:              this.sourceElement = new WeakReference(source);

  44:          }

  45:          ...

  46:      }

  47:  }

A CommandBehaviour instance is created when the EventName attached property is set and the targetDelegate member is set when the relevant event has been hooked. In my unit test, I wanted to check that this member was actually being set and here’s how I did it using the accessor:

   1:  [TestMethod]

   2:  [DeploymentItem("DerekLakin.Libraries.Presentation.dll")]

   3:  public void RemoveEventHandlerTest()

   4:  {

   5:      Grid source = new Grid();

   6:      source.SetValue(

   7:          CommandBehaviour.CommandProperty,

   8:          ApplicationCommands.Open);

   9:      source.SetValue(

  10:          CommandBehaviour.EventNameProperty,

  11:          "MouseLeftButtonUp");

  12:      CommandBehaviour real = (CommandBehaviour)

  13:          source.GetValue(

  14:              CommandBehaviour_Accessor.CommandBehaviourProperty);

  15:      CommandBehaviour_Accessor target =

  16:          new CommandBehaviour_Accessor(

  17:              new PrivateObject(real));

  18:      Assert.IsNotNull(target.targetDelegate);

  19:      target.RemoveEventHandler();

  20:      Assert.IsNull(target.targetDelegate);

  21:  }

First, I create a Grid instance and set the Command and EventName attached properties on it. Next, I get the CommandBehaviour instance from the Grid instance by using the accessor’s CommandBehaviourProperty (which is normally private). Then, I create a CommandBehaviour_Accessor instance that wraps the CommandBehaviour instance by using the PrivateObject class. Finally, I use regular Assert statements against the accessor to check the private members. Job done!

^* For more information about testing private methods, see How to: Test a Private Method on the MSDN web site.

This work is licensed under a Creative Commons Attribution By license.

Cloud-Based Source Control using Live Mesh and Git

noreply@blogger.com (Derek Lakin) — Mon, 08 Jun 2009 09:21:00 +0000

I’ve been working on a couple of projects recently where I’ve been storing the source in the cloud using Live Mesh so that I could access the solution from any of the PCs and laptops that litter the house. On the whole this approach has worked fairly well, although it results in a lot of changes through Mesh and occasionally locks files. The other drawback is that there is no file versioning and I like to be able to rollback some changes if I decide the approach I’ve taken isn’t working out for me.

I’ve had prior history of working with a number of different source control solutions and though that Subversion might be a good fit for a Mesh-based repository. Unfortunately, after creating a repository in the Mesh, AnkhSVN wouldn’t recognise the Mesh folder as a valid repository, so I couldn’t connect to it. Having given up on the possibility of getting working version control in the Mesh, I found Ten steps on how to store Git repositories in Live Mesh! by Pål Fossmo. I’d seen a lot of buzz about Git, but never actually tried it, so it though I’d give it a whirl. I was also interested in some kind of integration in Visual Studio and found the Git Extensions, which include an add-in for Visual Studio, so I modified the original approach slightly and came up with my own:

Ten Steps to Storing Git Repositories in the in Live Mesh

Install. Download and install Git Extensions from http://code.google.com/p/gitextensions (I used 1.62, but there is a version 1.64 as I write this post), which includes Git 1.6.2.2, by using the default values during installation.
Mesh Account. Create a Live Mesh account if you don’t already have one at http://www.mesh.com.
Mesh Folder. Create a folder in the Mesh and synchronise it with the required devices. I called mine Repository.
Local Repository. To create a local repository, navigate to the folder containing your source code, right-click, click Git GUI Here, and then click Create New Repository. In the Git Gui dialog, select the target folder, and then click Create. Git displays a dialog showing the files that will be added.
Exclude Files. To exclude files that you don’t want to be version controlled, edit the file named exclude in: <New repository>\.git\info\. My exclude file uses the defaults for Visual Studio plus a few extras, such as *.vsmdi.
Commit Initial Version. In the Git Gui dialog (from Step 4), click Rescan to update the list of files to be added, type “Initial version.” into the Commit Message box, and then click Commit.
Clone the Repository into the Mesh. Open your solution in Visual Studio, and then open a file (any source file it doesn’t matter^*). On the Git menu, click Clone repository. In the Clone dialog, make sure the Repository to clone folder is correct, select the destination folder, which is your Mesh folder, enter the name of the Subdirectory to create, select Central repository, no working dir (--bare), and then click Clone.
Push Changes to the Mesh. Commit local changes as usual by using the Commit button on the Git Extensions toolbar. When you are ready to push some changes into the Mesh: in Visual Studio, click Push changes to remote repository on the Git Extensions toolbar. In the Push dialog, select Url, click Browse to select the Mesh folder to push to, select master from the Branch to push list, and then click Push.
Get Source Files on Different PC. Install Git Extensions as described in Step 1. Create a folder to contain the source files, and then create a local repository as described in Step 4. Update the exclude file as described in Step 5.
Pull the Source From the Repository. Right-click the folder for the new repository, and then click Git Bash Here. In the command prompt, type:
git pull C:/Users/<user>/Desktop/Repository/<SubFolder> master
You now have the same source files on both PCs. You can use the push and pull buttons on the Git Extensions toolbar in Visual Studio to transfer changes via the Mesh.

^* The Git Extensions add-in for Visual Studio is a regular add-in, not a source control provider. For any command to work, you must have a source file open.

Side Note

If you want to see your own name in the version history, click Settings on the Git Extensions toolbar, and enter your details on the Global Settings tab. You can also change the merge tool on this tab (I personally prefer SourceGear’s DiffMerge).

This work is licensed under a Creative Commons Attribution By license.

Fractured Metacarpal

noreply@blogger.com (Derek Lakin) — Tue, 21 Apr 2009 08:58:00 +0000

Not wanting to be outdone by my Mum who broke her arm in New Zealand recently, yesterday (after 33 years with no broken bones) I managed to break the left little finger metacarpal.

I was cycling back from town when the chain slipped off the gears throwing the bike to the left and me into some iron railings. My little finger hyper flexed into my palm and snapped the metacarpal in the process.

I'm now bandaged up (no cast) and typing with one hand plus two fingers and a thumb!

This work is licensed under a Creative Commons Attribution By license.

Defining the Default Style for a Lookless Control

noreply@blogger.com (Derek Lakin) — Tue, 14 Apr 2009 16:24:00 +0000

Microsoft introduced the concept of “lookless” controls in WPF, which means that the control defines its behaviour without any information about how it actually looks, which is where templates and styles come in. However, all of the default controls provide a default look, which is in keeping with the current Windows theme (Aero in Windows Vista, Luna, Metallic, or Homestead in Windows XP and so on). If you are creating lookless controls in a class library for general consumption, it would be helpful to also provide a default look for your controls. To achieve this, there are three things that you need to do.

Note: This article refers specifically to custom controls (i.e. those that inherit from Control, FrameworkElement or similar, not user controls that inherit from UserControl). For more information about creating controls for WPF, see Control Authoring Overview on the MSDN web site.

1. Override the Metadata for the DefaultStyleKey Property

In a static constructor for your control, set the default style key to the type name, which is used to do style lookups for your control. The following code example shows the static constructor for a Wizard class that I’m creating.

   1:  static Wizard()

   2:  {

   3:      DefaultStyleKeyProperty.OverrideMetadata(

   4:          typeof(Wizard),

   5:          new FrameworkPropertyMetadata(typeof(Wizard)));

   6:  }

2. Define Your Default Style

You can create a default style for each of the different Windows themes. To do this you need to create resource dictionary with a specific name in a Themes folder that is a subfolder of the folder that contains your control in your class library. The following table provides the file names of the theme-specific resource dictionaries.

Resource dictionary	Windows theme
Classic.xaml	“Classic” Windows 9x/2000 look on Windows XP
Luna.NormalColor.xaml	Default blue theme on Windows XP
Luna.Homestead.xaml	Olive theme on Windows XP
Luna.Metallic.xaml	Silver theme on Windows XP
Royale.NormalColor.xaml	Default theme on Windows XP Media Center Edition
Aero.NormalColor.xaml	Default theme on Windows Vista

You don’t need to provide a style for every theme. If there is no theme-specific resource, then the generic resource is used for the control, which is defined in the Themes\generic.xaml resource dictionary.

The following XAML code example shows the default style in generic.xaml for the Wizard class described above.

   1:  <ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

   2:                      xmlns:local="clr-namespace:DerekLakin.Libraries.Presentation"

   3:                      xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">

   4:      <Style TargetType="{x:Type local:Wizard}">

   5:          <Setter Property="Template">

   6:              <Setter.Value>

   7:                  <ControlTemplate TargetType="{x:Type local:Wizard}">

   8:                      <DockPanel LastChildFill="True">

   9:                          <WrapPanel DockPanel.Dock="Bottom"

  10:                                     HorizontalAlignment="Right"

  11:                                     Orientation="Horizontal"

  12:                                     Margin="10">

  13:                              <Button x:Name="PART_Back"

  14:                                      Content="Back" />

  15:                              <Button x:Name="PART_Next"

  16:                                      Content="Next"

  17:                                      Margin="4,0,0,0" />

  18:                              <Button x:Name="PART_Cancel"

  19:                                      Content="Cancel"

  20:                                      Margin="4,0,0,0" />

  21:                              <Button x:Name="PART_Finish"

  22:                                      Content="Finish"

  23:                                      Margin="4,0,0,0" />

  24:                          </WrapPanel>

  25:                          <Frame x:Name="PART_Frame"

  26:                                 NavigationUIVisibility="Hidden" />

  27:                      </DockPanel>

  28:                  </ControlTemplate>

  29:              </Setter.Value>

  30:          </Setter>

  31:      </Style>

  32:  </ResourceDictionary>

3. Add the ThemeInfo Attribute to AssemblyInfo

The final part is to publicise the fact that your assembly contains control-specific resources, which you do by using the ThemeInfo attribute. The GenericDictionaryLocation property defines where the generic resources are and the ThemeDictionaryLocation property defines where the themed resources are. The value for both properties is a ResourceDictionaryLocation enumeration, which is None, SourceAssembly, or ExternalAssembly.

The following code example shows the ThemeInfo attribute for the class library project that contains the Wizard class described previously, which has no theme-specific resources, but does specify a generic resource.

   1:  [assembly: ThemeInfo(ResourceDictionaryLocation.None,

   2:      ResourceDictionaryLocation.SourceAssembly)]

Side Note

If your custom control has specific parts that are key to the operation of the control (such as the buttons and frame in the Wizard example described previously), then the convention is to name them using the “PART_” prefix in the control template. For each required part in your template, you should add a TemplatePart attribute to the class definition as shown in the following code example.

   1:  [TemplatePart(Name = "PART_Frame", Type = typeof(Frame))]

   2:  [TemplatePart(Name = "PART_Back", Type = typeof(Button))]

   3:  [TemplatePart(Name = "PART_Cancel", Type = typeof(Button))]

   4:  [TemplatePart(Name = "PART_Finish", Type = typeof(Button))]

   5:  [TemplatePart(Name = "PART_Next", Type = typeof(Button))]

   6:  public class Wizard : Window

You should get a reference to these named template parts in the OnApplyTemplate override of your class because this is the point where the control template has actually been applied. It is common not to specifically handle missing template parts so that an exception (typically a NullReferenceException) gets raised at runtime, which clearly indicates that something is broken.

The following code example shows the OnApplyTemplate override for the Wizard class described previously.

   1:  public override void OnApplyTemplate()

   2:  {

   3:      base.OnApplyTemplate();

4:

   5:      // Get the template parts.

   6:      this.navigationFrame = this.GetTemplateChild("PART_Frame") as Frame;

   7:      this.back = this.GetTemplateChild("PART_Back") as Button;

   8:      this.cancel = this.GetTemplateChild("PART_Cancel") as Button;

   9:      this.finish = this.GetTemplateChild("PART_Finish") as Button;

  10:      this.next = this.GetTemplateChild("PART_Next") as Button;

  11:  }

For more information about designing lookless controls, see Guidelines for Designing Stylable Controls on the MSDN web site.

This work is licensed under a Creative Commons Attribution By license.

Appeal for IT Professional

noreply@blogger.com (Derek Lakin) — Thu, 26 Mar 2009 20:50:00 +0000

In a departure from my usual posts (if you can call not posting for nearly six months "usual"!), I'd like to make an appeal on behalf of my wife's company for someone with IT infrastructure/system adminstration experience who would be willing to help them out. The specification for the work is as follows:

We are a cutting edge Technology Company based on the Cambridge Science Park. We have been at this facility for five years in October 2009 and now require a business analysis to be carried out on our existing business processes and information systems.

We are therefore seeking an Independent IT Professional who is NOT tied to an agency or IT company. This is strictly for an independent review of our business systems to enable us to go out to the market for quotes for the necessary work to be carried out.

We will be looking for recommendations on processes and information system improvements to carry us through the next five years. Presently our IT is out-sourced to a local company and aided internally by our Office Administrator with the Direction of our Director of HR & Administration who has responsibility for this area of the business.

Project Detail

To conduct a business analysis with input from key people within the business

Recording and analysis of interviews with key staff

Analysis of the use of existing business process and systems

An appropriate costed solution to meet the long term requirements and business challenges of the organisation

A GAP analysis

A proposal for the solution to meet future business needs

If this mini-project is of interest to you, please contact: Julie Lakin, Director of HR & Administration at Julie.lakin@SmartHolograms.com or by telephone on 01223 393400.

Migrating a Legacy WPF Application to Prism - Part 2

noreply@blogger.com (Derek Lakin) — Mon, 06 Oct 2008 11:52:00 +0000

After my initial successes in moving to a Prism-style bootstrapper in Part 1 it was time to move onto the next step. But in the case of a legacy application, what's the next step?

Application Structure Overview

Our legacy application consists primarily of a WPF user interface, a WCF service that provides access to a SQL Server database and a few support libraries. One of those support libraries provides some classes that deal with the interaction between the user interface and the WCF service and is my prime candidate for making some improvements using the Prism guidance.

There are two main entities, one that relates to a Project that is handled by the application and one that relates to a Pages, which make up the contents of a Project. So these seemed to me to be good choices for modules. But, the existing infrastructure merges the roles of Service and ViewModel into a single class, which I'd like to separate.

So, my plan (so far at least) is to create Prism Modules for the Project and Page and to create the relevant Views, ViewModels, Services, and Controllers that are required to implement the functionality. Rather than having to fully re-write the underlying code that handles UI/WCF Service interaction, I'm planning on writing a Prism-facade that will simply call out to the existing infrastructure, which I can eventually replace as time progresses. This gives me the testability advantages of Prism without having to rip out the heart of the application and re-write it completely, which would be a costly and time consuming task.

Getting Started

For my next step I'm focusing on the Project aspects of the application, so (as you can see in the screen shot above) I've created a Project module containing the ProjectModule, a ProjectService, ProjectTreeView, ProjectTreeViewModel and a ProjectController, which will handle the interactions between the different views of a project (when I get that far).

Each of these classes implements an interface, which enables me to easily mock these implementations to test specific aspects of the application. At this stage my implementations are very simple in that they just initialise the relevant Views, ViewModels, etc. The View itself is simply a UserControl that contains a root Grid element with a pink background. The important thing is to get it loaded and displayed first.

Implementation Specifics

In the application's shell, the existing user control was removed and replaced with the following region definition.

<ContentControl x:Name="_navigation"
                cal:RegionManager.RegionName="{x:Static inf:RegionNames.Navigation}"
                DockPanel.Dock="Left" />

The "cal" XML namespace resolves to "http://www.codeplex.com/CompositeWPF" and the "inf" XML namespace resolves to an infrastructure assembly that contains constants for the region names.

The ProjectController class retrieves the relevant region that is the destination of the View and adds the View for the associated ViewModel to that region and then activates it as shown in the following code example.

public void Run()
{
    IRegion region = this._regionManager.Regions[RegionNames.Navigation];
    region.Add(this._projectTreeViewModel.View);
    region.Activate(this._projectTreeViewModel.View);
}

The call to the Activate method is essential if you want to be able to see your View. Until the Activate method is called, you will not be able to see your View.

The Run method of the ProjectController is called in the Initialize method of the ProjectModule after registering the required views and services, as shown in the following code example.

#region Private Methods  private void RegisterViewsAndServices()
{
    // NOTE: The ContainerControlledLifetimeManager ensures that the same
    //       instance is returned by any call to Resolve or ResolveAll.
    this._container.RegisterType<IProjectService, ProjectService>(new ContainerControlledLifetimeManager());
    this._container.RegisterType<IProjectController, ProjectController>(new ContainerControlledLifetimeManager());
    this._container.RegisterType<IProjectTreeView, ProjectTreeView>();
    this._container.RegisterType<IProjectTreeViewModel, ProjectTreeViewModel>();
}

#endregion Private Methods  #region IModule Members

public void Initialize()
{
    RegisterViewsAndServices();
    IProjectController controller = this._container.Resolve<IProjectController>();
    controller.Run();
}

#endregion

As you can see in the screen shot above, apart from writing all the tests, putting some simple content in the ViewModel, a bit of work on the infrastructure and doing a lot of head scratching, that's it! Granted it's just a pink rectangle at the moment, but I now have a View that is loaded into the right place.

My next step is to put some useful UI code into the View and try to gradually incorporate some of the visual functionality of it's predecessor.

Migrating a Legacy WPF Application to Prism - Part 1

noreply@blogger.com (Derek Lakin) — Thu, 02 Oct 2008 09:13:00 +0000

This is the first of several posts on my journey migrating a legacy application to use the Composite Application Guidance for WPF, which (like Brian Noyes) I prefer to call Prism, mainly because it's shorter, but it's also cooler!

I've watched the "Brian Noyes on Prism" dnr TV episode intently, read through the guidance documentation, I've done the hands-on lab, all of the quick starts and dissected and analysed the StockTraderRI sample application, so now I figure I'm ready to start cranking some Prism code for our legacy application¹.

¹By "legacy" I mean that it's a regular WPF application that was not created using the Prism (or any other specific) guidance, so it's not a green field project.

Understanding the Terminology

I don't pretend to be completely clued up on all aspects of design patterns, but I'm aware of the key concepts behind Model-View-Controller (MVC) and it's numerous variants, so when I opened up the StockTraderRI sample application I was initially a bit confused to see a combination of Presenters from Model-View-Presenter (MVP; also referred to as Supervising Controller in the guidance), Controllers from MVC, and PresentationModels from Presentation Model, or Model-View-ViewModel (MVVM) to give it its more WPF-focused name.

After a bit of digging it was clear that the Prism team were using a mixture of approaches and for good reason (of course), which I thought I'd just quickly explain for my own recording purposes if nothing else.

Model: The underlying business entities that represent the data in your system (pretty much standard throughout all of the MV* patterns). E.g. StockTraderRI.Infrastructure.Models.NewsArticle class in the StockTraderRI sample.
View: The user interface representation of the underlying Model (also pretty much standard throughout all of the MV* patterns). E.g. StockTraderRI.Modules.News.Article.ArticleView class in the StockTraderRI sample.
Presenter: When the Model can provide the data that the View requires without any complex manipulation or transformation, then the View binds directly to the Model and the Presenter handles the state of the View in the cases where complex user interface logic is required, such as changing colours of controls and showing/hiding controls. E.g. StockTraderRI.Modules.News.Article.NewsReaderPresenter class in the StockTraderRI sample. The NewsReader View binds directly to properties of the NewsArticle Model class, which is supplied by the NewsReaderPresenter.
PresentationModel: When the View cannot bind directly to the Model, a PresentationModel class is used to provide the Model in a format more easily consumed by the View acting as a façade. The PresentationModel class also manages UI-specific state and behaviour. E.g. StockTraderRI.Modules.News.Article.ArticlePresentationModel class in the StockTraderRI sample. The ArticleView class binds Articles property exposed by the ArticlePresentationModel class. Note: Given that MVVM is a WPF-specific variation of Martin Fowler's Presentation Model pattern, I prefer the term ViewModel to PresentationModel; if nothing else it's shorter :)
Controller: The StockTraderRI sample application uses Controller classes to manage the interaction between multiple views. E.g. StockTraderRI.Modules.News.Controllers.NewsController class, which manages interactions between the ArticleView and the NewsReader View via the ArticlePresentationModel and NewsReaderPresenter.

There is a discussion about the patterns used in Prism (and hence the sample application) in the guidance documentation, but the above helped to put things straight in my mind.

Getting Started

The first thing I did to get me started down the road to a Prism-based application was to implement the Bootstrapper, which I did as follows:

Added references to the following Prism assemblies in my main (shell) project:
- Microsoft.Practices.Composite.dll
- Microsoft.Practices.Composite.Wpf.dll
- Microsoft.Practices.UnityExcetions.dll
- Microsoft.Practices.Unit.dll
- Microsoft.Practices.ObjectBuilder.dll

Added a new class called MyApplicationBootstrapper², which inherits from UnityBootstrapper as shown in the following code example.

    public class MyApplicationBootstrapper : UnityBootstrapper
    {
        protected override DependencyObject CreateShell()
        {
            MainWindow window = new MainWindow();
            window.Show();
            return window;
        }

        protected override IModuleEnumerator GetModuleEnumerator()
        {
            return new StaticModuleEnumerator();
        }
   }

Removed the StartupUri property from App.xaml.
Created an instance of in the Application.Startup event handler as shown in the following code example.

private void Application_Startup(object sender, StartupEventArgs e)
{
    MyApplicationBootstrapper bootstrapper = new MyApplicationBootstrapper();
    bootstrapper.Run();
}

² I've substituted "MyApplication" for the name of the actual application to protect the interests of my employer.

So far so good. The application runs as it did before but now it uses a Bootstrapper. Nothing dramatic and no big benefits yet, but it works. Next step, start writing some tests and a some modules to contain the existing UI controls as views in a more Prism-like approach.

Note: I welcome (encourage even) any corrections/comments/etc about the approach that I'm taking or on any of the detail that I've included in this post (and future posts).

Changing the Caret Colour in WPF

noreply@blogger.com (Derek Lakin) — Tue, 16 Sep 2008 16:21:00 +0000

In WPF, you don’t have direct control over the colour of the caret in a TextBox or a RichTextBox. What the framework does is to use the inverse of the colour that you choose for the Background property. I’ve seen a few examples of styles that explicitly set the Background property to {x:Null} to completely remove the background from the TextBox, which enables you to use the same style when then the TextBox is used on top of different backgrounds that you want to show through.

Because the framework uses the inverse of the Background colour to set the colour of the caret, if you set the Background property to {x:Null}, then you will end up with the default black caret, which on a black background can be particularly difficult to see!

The Solution

The simple solution to this problem is to use actually specify a value for the Background property. In the case where you have a black background and want a white caret, then you can set the value of the Background property to #00000000, which is completely transparent black (if that makes sense!). The framework appears to ignore the opacity component of the colour so you end up with a transparent background and a white caret!

Taking it One Step Further

I haven’t tried this yet, but I assume that you can take this approach one step further to customise the colour of your caret by setting the Background to different colours with an opacity value of zero. This would then be a simpler solution that completely overriding the style as described by Lester in his Changing caret color in (Rich)TextBox post.

This work is licensed under a Creative Commons Attribution By license.

Determining the Relative Path in XLinq with Extension Methods

noreply@blogger.com (Derek Lakin) — Mon, 21 Jul 2008 15:52:00 +0000

Introduction

In Titan, I’m edging closer and closer to releasing a beta 1 for public consumption and one of the tasks that I’m working on to get me there is a lazy-loading folder browser dialog box that enables you to browse through the folder structure of a particular service without having to load the whole folder structure in one go. This is used specifically for specifying new service configurations and is of particular concern for the local file system provider. Have you ever tried to retrieve your whole hard disk structure in one go!?

My service methods were already using some XLinq to parse the XML response from the Box.net service call and the local file system provider, but for the Box.net service provider I needed a way of finding a particular folder based on it’s relative path. The contents of a fictitious Box.net folder structure could look like the following XML example.

<folder id="0" name="" shared="0">
  <tags></tags>
  <files></files>
  <folders>
     <folder id="4384" name="Incoming" shared="0">
        <tags>
           <tag id="34" />
         </tags>
         <files>
            <file id="68736" file_name="cows.w3g" keyword="" shared="0" size="232386" created="1129537520" updated="1129537520">
               <tags>
               </tags>
            </file>
            <file id="68737" file_name="silver.html" keyword="" shared="0" size="15805" created="1129537520" updated="1129537520">
               <tags>
                  <tag id="35" />
               </tags>
            </file>
         </files>
         <folders>
             <folder id="1234" name="Test" shared="0">
                <folders>
                    <folder id="2345" name="wibble" shared="0">
                        <folders />
                    </folder>
                    <folder id="5432" name="wobble" shared="0">
                        <folders />
                    </folder>
                </folders>
            </folder>
            <folder id="4321" name="Test2" shared="0">
                <folders />
            </folder>
         </folders>
      </folder>
   </folders>
</folder>

The Problem

So, if I want to retrieve the folder contents of the folder named Test, which has a relative path of “\Incoming\Test”, how do I find that in XLinq? Well, I looked at all kinds of different approaches using the Descendants and Ancestors methods, but none of them managed to produce the goods, because I needed a single string that I could compare against.

The Solution

To solve the problem I decided to use an extension method to produce a single string from a collection. The results of an XLinq query are IEnumerable<T>, where T depends on the exact nature of the query. In my case, I was pulling out the name attribute, so I had IEnumerable<string>. The extension method shown in the following code example uses a StringBuilder to build up the single string.

/// <summary>
/// Converts the IEnumerable<string> to a single string.
/// </summary>
/// <param name="source">The source IEnumerable<string>.</param>
/// <returns>A single string that represents the contents of the IEnumberable<string></returns>
public static string ToOneString(this IEnumerable<string> source)
{
    StringBuilder builder = new StringBuilder();

    // Add each item.
    foreach (string item in source)
    {
        if (item.Length > 0)
        {
            builder.Append(item);
        }
    }

    return builder.ToString();
}

This didn’t quite solve the problem, because for my scenario described above, this produces a single string of “IncomingTest”, which isn’t quite a relative path. So, I added an overload for the method that accepts a string separator to produce the following.

/// <summary>
/// Converts the IEnumerable<string> to a single string.
/// </summary>
/// <param name="source">The source IEnumerable<string>.</param>
/// <returns>A single string that represents the contents of the IEnumberable<string></returns>
public static string ToOneString(this IEnumerable<string> source)
{
    return source.ToOneString(string.Empty);
}

/// <summary>
/// Converts the IEnumerable<string> to a single string.
/// </summary>
/// <param name="source">The source IEnumerable<string>.</param>
/// <param name="separator">A separator to be placed between each item in the string.</param>
/// <returns>A single string that represents the contents of the IEnumberable<string></returns>
public static string ToOneString(this IEnumerable<string> source, string separator)
{
    StringBuilder builder = new StringBuilder();

    // Add each item and the separator.
    foreach (string item in source)
    {
        if (item.Length > 0)
        {
            builder.Append(item);
            builder.Append(separator);
        }
    }

    // Remove the final separator.
    if (builder.Length >= separator.Length)
    {
        builder.Remove(builder.Length - separator.Length, separator.Length);
    }

    return builder.ToString();
}

In my reusable library, I’ve also created a version of ToOneString for IEnumerable<T>, which simply appends item.ToString() to the StringBuilder.

And Finally

So, my final XLinq query that builds up the relative path and returns me the folders for a specific relative path looks like the following code example, where relativePath is a string parameter to the method that specifies the relative path to the folder that I want to retrieve the child folders.

var query = 
    (from d in xRoot.DescendantsAndSelf("folder")
     where "\\" + (from a in d.AncestorsAndSelf("folder")
                   select a.Attribute("name").Value).Reverse().ToOneString("\\") == relativePath
     select d.Element("folders").Elements("folder")).First();

If there are any folders in the specified folder, then I can enumerate the resulting XElement collection and build up instances of my File class.

This work is licensed under a Creative Commons Attribution By license.

Creating a Custom View Mode that Supports a Template Selector

noreply@blogger.com (Derek Lakin) — Thu, 26 Jun 2008 07:17:00 +0000

Background

The controls that inherit from ItemsControl (such as ListBox, ListView, and so on) expose an ItemTemplateSelector property that you can use instead of the ItemTemplate property to specify a DataTemplateSelector. The DataTemplateSelector enables you to specify your own custom logic that determines which DataTemplate should be applied to each item.

There are a number of blog posts out there already that give good instructions on how to implement a DataTemplateSelector, typically for tasks such as selected item highlighting or alternate background colours for list boxes, so I won’t go into the details there. The Queen of Data Binding: Bea Costa, has a great post on the subject: How do I display items in an ItemsControl using different templates?

The Problem

However, there seems to be very few resources (none that I could find) that show you how to implement a custom view mode for the ListView control that implements that same template selection functionality, which brings me to the purpose of this post.

In Titan, the main files and folders view is created by using a ListView control that uses a custom view mode (like GridView, but this one does a Windows Explorer style tile view). The problem I had was that I wanted to always use the same icon for a folder, but to use a different icon for a file depending on it’s file extension. I managed to achieve this initially by using triggers, but then I realised that I wanted to provide different commands for files and folders.

The available commands are bound onto the ContextMenu for each item and the triggers approach just wasn’t working for trying to change the context menu, so I came to the realisation that what I actually wanted was a separate DataTemplate for files and folders. The problem was that because I was using a custom view mode, I couldn’t use the ItemTemplateSelector on the ListView itself. Looking at the implementation of the GridView I realised that I could do what I wanted by implementing template selection on my custom view mode, which is what the GridView does by using the ColumnHeaderTemplateSelector.

The Solution

1. Implement a Custom View Mode

To implement a custom view mode, you create a class that inherits from the ViewBase class. For more information on custom view modes, see How to: Create a Custom View Mode for a ListView on the MSDN web site.

There are three important additional steps to take to enable template selection for your custom view mode:

Add a new dependency property to expose the DataTemplateSelector.
Change the dependency property definition for the existing ItemTemplate dependency property to use a PropertyChangedCallback that checks to see if both the ItemTemplate and ItemTemplateSelector have been specified.
Override the PrepareItem method. This is called for each item in advance of it’s display, which gives you the opportunity to call SelectTemplate on the supplied DataTemplateSelector.

The following code example shows the relevant parts of my custom view mode.

using System.Diagnostics;
using System.Windows;
using System.Windows.Controls;

namespace DerekLakin.Libraries.Controls
{
    public class TileView : ViewBase
    {
        #region Dependency Properties
        ...
        public static readonly DependencyProperty ItemTemplateProperty =
            DependencyProperty.Register("ItemTemplate", typeof(DataTemplate), typeof(TileView),
                new FrameworkPropertyMetadata(
                    new PropertyChangedCallback(TileView.OnItemTemplateChanged)));

        public DataTemplate ItemTemplate
        {
            get { return (DataTemplate)GetValue(ItemTemplateProperty); }
            set { SetValue(ItemTemplateProperty, value); }
        }

        public static readonly DependencyProperty ItemTemplateSelectorProperty =
            DependencyProperty.Register("ItemTemplateSelector",
                typeof(DataTemplateSelector), typeof(TileView), 
                new FrameworkPropertyMetadata(
                        new PropertyChangedCallback(TileView.OnItemTemplateSelectorChanged)));

        public DataTemplateSelector ItemTemplateSelector
        {
            get { return (DataTemplateSelector)GetValue(ItemTemplateSelectorProperty); }
            set { SetValue(ItemTemplateSelectorProperty, value); }
        }

        public static readonly DependencyProperty ItemWidthProperty =
            WrapPanel.ItemWidthProperty.AddOwner(typeof(TileView));

        public double ItemWidth
        {
            get { return (double)GetValue(ItemWidthProperty); }
            set { SetValue(ItemWidthProperty, value); }
        }
        #endregion

        #region Overrides
        ...
        protected override void PrepareItem(ListViewItem item)
        {
            base.PrepareItem(item);

            object selector = this.ReadLocalValue(TileView.ItemTemplateSelectorProperty);
            object template = this.ReadLocalValue(TileView.ItemTemplateProperty);
            if (((null != selector) &&
                 (DependencyProperty.UnsetValue != selector)) &&
                ((null != template) &&
                 (DependencyProperty.UnsetValue != template)))
            {
                // Both ItemTemplate and ItemTemplateSelector have been set.
                item.ContentTemplate = this.ItemTemplate;
            }
            else if ((null != selector) &&
                (DependencyProperty.UnsetValue != selector))
            {
                // Just ItemTemplateSelector has been set.
                item.ContentTemplate = 
                    this.ItemTemplateSelector.SelectTemplate(item, this);
            }
            else
            {
                // Default to ItemTemplate.
                item.ContentTemplate = this.ItemTemplate;
            }
        }
        #endregion

        #region Property Changed Handlers
        private static void OnItemTemplateChanged(DependencyObject d, 
            DependencyPropertyChangedEventArgs e)
        {
            TileView view = (TileView)d;
            // Check that a value hasn't already been set for the 
            // ItemTemplateSelector property.
            object selector = d.ReadLocalValue(TileView.ItemTemplateSelectorProperty);
            if ((null != selector) &&
                (DependencyProperty.UnsetValue != selector))
            {
                Trace.WriteLine("Cannot specify ItemTemplate and ItemTemplateSelector for a TileView. Using ItemTemplate.");
            }
        }

        private static void OnItemTemplateSelectorChanged(DependencyObject d, 
            DependencyPropertyChangedEventArgs e)
        {
            TileView view = (TileView)d;
            // Check that a value hasn't already been set for the 
            // ItemTemplate property.
            object template = d.ReadLocalValue(TileView.ItemTemplateProperty);
            if ((null != template) &&
                (DependencyProperty.UnsetValue != template))
            {
                Trace.WriteLine("Cannot specify ItemTemplate and ItemTemplateSelector for a TileView. Using ItemTemplate.");
            }
        }
        #endregion
    }
}

2. Implement the DataTemplateSelector

To implement your DataTemplateSelector, you need to provide properties for the templates that the user can choose from. In my case there are two options: the FileDataTemplate and the FolderDataTemplate. You also need to override the SelectTemplate method to provide the logic that determines which template to return.

The following code example shows my DataTemplateSelector:

using System.Windows;
using System.Windows.Controls;
using DerekLakin.Libraries.Synchronization;

namespace DerekLakin.Applications.Titan.Controls
{
    public class FilesAndFoldersDataTemplateSelector: DataTemplateSelector
    {
        public DataTemplate FileDataTemplate { get; set; }
        public DataTemplate FolderDataTemplate { get; set; }

        public override DataTemplate SelectTemplate(object item, 
            DependencyObject container)
        {
            ListViewItem targetItem = (ListViewItem)item;
            if (targetItem.DataContext is VirtualFile)
            {
                return FileDataTemplate;
            }
            else
            {
                return FolderDataTemplate;
            }
        }
    }
}

3. Bringing it All Together

To bring it all together, you need to create data templates for the selector to choose from. Then you need to create an instance of the DataTemplateSelector. Finally, you need to specify the template selector on the custom view mode (I’m assuming you already have an instance of the custom view mode and the ListView that uses it).

The following XAML code example shows the relevant parts.

    <DataTemplate x:Key="filesTemplate">

    ...
    </DataTemplate>
    <DataTemplate x:Key="foldersTemplate">

    ...
    </DataTemplate>

    <c:FilesAndFoldersDataTemplateSelector x:Key="filesAndFoldersTemplateSelector"
                                           FileDataTemplate="{StaticResource filesTemplate}"
                                           FolderDataTemplate="{StaticResource foldersTemplate}" />

    <controls:TileView x:Key="tileView" 
                       ItemTemplateSelector="{StaticResource filesAndFoldersTemplateSelector}"
                       ItemWidth="128" />

I’m planning (eventually) to evolve my TileView into something that enables the user to change the size of the tiles in the same way that Windows Explorer does, although it’s a way off for now. When I do, though, I’ll release it into the wild for everyone to enjoy and it will, of course, support template selection.

This work is licensed under a Creative Commons Attribution By license.

Spore Creature Creator

noreply@blogger.com (Derek Lakin) — Wed, 18 Jun 2008 13:00:00 +0000

I’ve been eagerly anticipating the release of Spore for so long I can’t remember how long I’ve been waiting for it! However, as a juicy teaser in advance of the release of Spore (still some 80 days away) they’ve released the Spore Creature Creator to whet our appetites.

The Flying BeerGut - The Stomp

The Spore Creature Creator enables you to create all manner of creatures, which you can then share and eventually use in the final game. You can also use creatures added to the community in the final game.

The Spore Creature Creator comes in two different flavours, the full version, which costs £4.99 here in the UK ($9.95 in the USA, €9.99 in Europe) and the free trial version, which only includes 25% of the body parts of the full version. If you purchase the full version, EA will provide you with a coupon to the same value for you to redeem against the full game when it is released. From what I can gather, this will only be valid if you purchase it from the EA web site.

In the space of literally a few minutes I managed to put together 3 very different creatures:

Oh yeah, one more thing: kudos to EA for providing sensible pricing for the full version. The price is roughly the same across the board, which really makes a change here in the UK where we’re used to having to pay almost double for most things compared to the US!

This work is licensed under a Creative Commons Attribution By license.

Moving a WPF Window with a WindowStyle of None

noreply@blogger.com (Derek Lakin) — Fri, 06 Jun 2008 11:01:00 +0000

In my previous post: Creating a Custom Window Style, I showed how to create a custom Style in WPF using WindowStyle.None and ResizeMode.NoResize. What bugged me about this approach was that you can’t move the custom window, because you have no Window chrome to drag around the screen.

I read one article that took a really “hard core” approach and used interop to use the SendMessage, ReleaseCapture, and MouseMove methods, but this is a very Win32-oriented approach and in actual fact, WPF provides a much easier approach.

To enable a user to move your window from any area on that window (not necessarily just the title if you want to do something really different), you simply handle the MouseLeftButtonDown event for a UIElement on your window and call the DragMove method, as shown in the following code example.

private void title_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
    DragMove();
}

Hooking it Up to the Style

Having defined the look-and-feel in a reusable Style, we need a way of hooking up the MouseLeftButtonDown event and handling it in our Window class. Unfortunately, this is a little bit tricky. If the Style is defined in the XAML that defines your Window then you can simply add the event handler for the relevant UIElement as you would for any other element. However, putting your Style in with your actual Window doesn’t give you a very reusable Style. Instead, give a fixed name to the element in your Style, such as PART_Title, and then get a reference to that element and hook the event in your Window class. Are you still with me?

The following XAML code example shows the named part in the Window Style.

<Style x:Key="MessageBox" TargetType="{x:Type Window}">
    ...
    <Setter Property="Template">
        <Setter.Value>
            <ControlTemplate TargetType="{x:Type Window}">
                <Border Background="{DynamicResource MessageBoxBackgroundBrush}"
                        BorderBrush="{DynamicResource MessageBoxBorderBrush}"
                        BorderThickness="1">
                    <Grid>
                        <Grid.RowDefinitions>
                            <RowDefinition Height="30" />
                            <RowDefinition />
                        </Grid.RowDefinitions>
                        <Grid x:Name="PART_Title">
                            <Grid.Background>
                                <LinearGradientBrush EndPoint="0.5,1" StartPoint="0.5,0">
                                    <GradientStop Color="#FF214F18" Offset="0"/>
                                    <GradientStop Color="#FF20361C" Offset="1"/>
                                </LinearGradientBrush>
                            </Grid.Background>
                            <Grid.ColumnDefinitions>
                                <ColumnDefinition />
                                <ColumnDefinition Width="30" />
                            </Grid.ColumnDefinitions>
                            <Label Style="{DynamicResource MessageBoxTitle}" Content="{TemplateBinding Title}" />
                            <Button x:Name="PART_Close"
                                    Content="{DynamicResource CloseButtonPath}"
                                    Grid.Column="1"
                                    Style="{DynamicResource CloseButton}"
                                    Padding="4" />
                        </Grid>
                        <AdornerDecorator Grid.Row="1">
                            <ContentPresenter Content="{TemplateBinding Content}" Margin="{TemplateBinding Margin}" />
                        </AdornerDecorator>
                    </Grid>
                </Border>
            </ControlTemplate>
        </Setter.Value>
    </Setter>
</Style>

All I’ve done from the previous version of the Style is to add an x:Name attribute with a value of PART_Title to the Grid that contains the title of the Window.

The following code example shows how to get a reference to that element and hook the mouse event in the CustomMessageBox class.

namespace CustomWindow
{
    /// <summary>
    /// Interaction logic for CustomMessageBox.xaml
    /// </summary>
    public partial class CustomMessageBox : Window
    {
        private MessageBoxResult _result = MessageBoxResult.None;
        private Button _close;
        private FrameworkElement _title;

        ...

        private void this_Loaded(object sender, RoutedEventArgs e)
        {
            this._close = (Button)this.Template.FindName("PART_Close", this);
            if (null != this._close)
            {
                if (false == this._cancel.IsVisible)
                {
                    this._close.IsCancel = false;
                }
            }

            this._title = (FrameworkElement)this.Template.FindName("PART_Title", this);
            if (null != this._title)
            {
                this._title.MouseLeftButtonDown += new MouseButtonEventHandler(title_MouseLeftButtonDown);
            }
        }

        private void title_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            DragMove();
        }

        ...
    }
}

Summary

So, if you want to enable window movement for custom styled windows, then you need to call the DragMove method from an event handler for the MouseLeftButtonDown event. In this example, the CustomMessageBox class provides that event handling. If you are using a Style that applies to multiple windows, then you will need to hook the mouse event in each class, or implement a base class that provides this functionality for you and inherit from that class.

As before, I’ve provided the (now updated) source code for the custom message box class.

This work is licensed under a Creative Commons Attribution By license.

Setting the Initial Focus in WPF

noreply@blogger.com (Derek Lakin) — Tue, 03 Jun 2008 09:29:00 +0000

In WPF dialog boxes, I quite often see some code which looks like the following code. example.

private void OnLoaded(object sender, EventArgs e)
{
    this._textSearch.Focus();
}

This is usually accompanied by some XAML that likes like the following XAML example.

<Window ...
        Loaded="OnLoaded">

Occasionally, I also see the event being setup up in the constructor. For some reason this really gets on my nerves. I much prefer to see event handlers defined in the XAML. I’m not quite sure what my objection is; I think I just prefer to see all the UI things in one place.

What this actually achieves (as you can probably work out), is that the control (in this case a TextBox) named _textSearch has focus when the dialog box is loaded. In actual fact, WPF provides a much easier way of setting the initial focus by using the FocusManager. The FocusManager provides a set of static methods, properties, and events that you use to determine and set the focus scope^[1] and to set the focused element within the focus scope.

So, using the FocusManager, you don’t need to handle the Loaded event and manually calling the Focus method as shown in the previous code examples, you can simply set the FocusedElement on the FocusManager as shown in the following code example.

<Window ...
        FocusManager.FocusedElement="{Binding ElementName=_textSearch}">

Simple, neat, all in one place, and no code-behind :)

^[1]For more information about focus scopes, see FocusManager Class on the MSDN web site.

This work is licensed under a Creative Commons Attribution By license.

Enhancing the BackgroundWorker Class

noreply@blogger.com (Derek Lakin) — Tue, 20 May 2008 08:32:00 +0000

Background

Amongst the inner complexities of Titan, there are a number of cases where I'm executing some actions asynchronously by using the BackgroundWorker class. These are primarily in the controller class which handles calls from the user interface to the back-end service providers for actions such as getting the account tree, creating new folders, etc.

The flow through the application is (simply) illustrated in the following diagram:

Figure 1. Background task flow.

The user interface makes a request on the Controller.
The Controller creates a BackgroundWorker instance and calls RunWorkerAsync, passing in the required parameter.
The BackgroundWorker makes the necessary calls on the Service Provider and then raises the RunWorkerCompleted event when it's done.
The Controller sends any response to the user interface.

So, What's the Problem?

Take uploading a new file for example. When the files has been uploaded, the user interface needs to know which file has just been uploaded so that the user interface can be updated to reflect that the file is now synchronized. Titan enables users to upload or download more than one file at a time, so there could be multiple transfer operations happening at the same time. Which means that the controller needs to know which operation has just finished.

The BackgroundWorker class enables you to pass a parameter to the

RunWorkerAsync method, which you can retrieve from the Argument property of the DoWorkEventArgs. Once you've finished, you can specify a result in the Result property of the same DoWorkEventArgs. This result is then available in the Result property of the RunWorkerCompletedEventArgs in the RunWorkerCompleted event handler. However, there's no access to the original argument that you supplied, which in my case makes it difficult to tie up which upload (for example) has completed.

OK, So What's the Solution?

One potential solution would be to create a struct that contains the result that I wanted to return initially and also the original argument, but personally I don't like these kind of solutions. It's like having an event args inside an event args!

The solution I employed was to create an EnhancedBackgroundWorker class that simply exposes the original argument. All it does is to provide a new RunWorkerAsync method, which stores the supplied argument (which is exposed as the Argument property), and then calls the base implementation of RunWorkerAsync.

The following code shows the EnhancedBackgroundWorker class.

using System.ComponentModel;

namespace DerekLakin.Libraries.Utilities.Thread
{
    /// <summary>
    /// Enhanced <see cref="BackgroundWorker"/> class that stores the
    /// argument supplied to the <code>RunWorkerAsync</code>
    /// method so that it is available in the relevant event handlers.
    /// </summary>
    public class EnhancedBackgroundWorker : BackgroundWorker
    {
        public object Argument { get; set; }

        public new void RunWorkerAsync(object argument)
        {
            this.Argument = argument;

            base.RunWorkerAsync(argument);
        }
    }
}

Now, in the RunWorkerCompleted event handler, I can access the originally supplied argument from the EnhancedBackgroundWorker (which is the sender parameter). Simple but effective. I like those kinds of solutions :)

This work is licensed under a Creative Commons Attribution By license.

Creating a Custom Window Style

noreply@blogger.com (Derek Lakin) — Fri, 09 May 2008 17:24:00 +0000

I'm currently neck deep in refactoring an application for my company and one of the issues that I've just finished tidying up was that of providing a custom Window Style. The original application developer (in his infinite wisdom) had the same markup in every single file to produce the same look-and-feel and then used a complicated WindowHelper class to load the user control into an actual Window.

If you didn't know already, we can simplify this whole process greatly by applying a Style to the Window and implementing whatever appearance you want in the ControlTemplate. In the rest of this article, I'll show you how to implement a custom Style by implementing a custom message box.

Elements of a Custom Window Style

1. Remove the Borders

The first thing we need to do is to remove the standard window chrome, borders, etc. At first glance you might think that setting the window's WindowStyle to WindowStyle.None would do the trick, but as you can see from the following images, this still leaves us with a border. In order to remove all borders completely, you need to set the window's ResizeMode to ResizeMode.NoResize.

Figure 1. Regular Window.

Figure 2. WindowStyle set to None.

Figure 3. WindowStyle set to None and ResizeMode set to NoResize.

The following example XAML code shows how to define these properties in the XAML for your Window:

<Window
    ...
    ResizeMode="NoResize"
    WindowStyle="None">

Another use for this approach is to implement a custom splash screen.

2. Define a New Style

It's all very well putting the WindowStyle and ResizeMode in each Window, but if we want to apply our new look-and-feel to multiple windows then we need to put it into a Style.

The following example XAML code shows how to define the WindowStyle and ResizeMode values in a custom Window style.

<Style x:Key="MessageBox" TargetType="{x:Type Window}">
    <Setter Property="ResizeMode" Value="NoResize" />
    <Setter Property="WindowStyle" Value="None" />
</Style>

The following example XAML code shows how to apply this style to our custom window.

<Window
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="CustomWindow.CustomMessageBox"
    Style="{DynamicResource MessageBox}"
    ...>

3. Custom Look-and-Feel

The next thing we need to do is to make our custom window look the way we want it to. To do this we provide a ControlTemplate in our Window Style as you can see in the following picture:

You use regular WPF layout controls and elements to provide the look-and-feel that you require, but it's worth mentioning three things.

You need to include a ContentPresenter element in your ControlTemplate so that the XAML that you supply in the Window definition gets displayed. You should bind the Content property of the ContentPresenter to {TemplateBinding Content} as shown in the following example XAML code.
You should wrap your ContentPresenter element in an AdornerDecorator element. This isn't strictly necessary unless you want to support drag-and-drop, but it won't hurt to include it just in case.
If you want to display the window title somehow (which is still likely even though you're using a custom look-and-feel), you can use a template binding to access the regular Window.Title property.

<Style x:Key="MessageBox" TargetType="{x:Type Window}">
    ...
    <Setter Property="Template">
        <Setter.Value>
            <ControlTemplate TargetType="{x:Type Window}">
                ...
                <Label Content="{TemplateBinding Title}" />
                ...
                <AdornerDecorator>
                        <ContentPresenter
                            Content="{TemplateBinding Content}" 
                            Margin="{TemplateBinding Margin}" />
                </AdornerDecorator>
            </ControlTemplate>
        </Setter.Value>
    </Setter>
</Style>

Creating a Custom Message Box

Now that we've got all of the elements of a custom Window Style, moving to a custom message box is just a matter of implementation. The attached sample code includes an almost complete implementation of a Message Box including setting the message box buttons, image, caption, text, and default result. I won't bore you with the details, just download it and take a look, but there are a couple of points worth noting.

Setting the WindowStartupLocation

The WindowStartupLocation property isn't a dependency property, so we can't set it in the Style and apply it to all of our custom windows. The custom message box class simply sets it in the window XAML, but you should be aware of this for your own custom windows.

Binding to Enumerations

I've blogged about binding to enumerations before, but I came across an interesting problem when producing the sample application.

I wanted to bind a ComboBox to the MessageBoxImage enumeration, but this enumeration has several names that resolve to the same value (Asterisk and Information, Error, Hand and Stop, and Exclamation and Warning), so a call to Enum.GetValues results in a list of the enumerated values being recalled. When the binding engine binds the resulting list of values in the ComboBox, it uses the ToString method to display the name of the enumeration. However, because several of the names resolve to the same name, I was getting the first name repeated multiple times.

This makes sense, because there is no way for the binding engine to resolve the same number to different string names.

The solution was to use the GetNames method instead, which results in a list of strings being returned to the ComboBox. As a result, you need to set the SelectedValue using the appropriate string value instead of an actual enumeration in the SelectedItem to set the initial selection, and you'll need to use the System.Enum.Parse method if you want to get an enumeration from the SelectedItem.

I hope you find some or all of this useful. Feel free to use the attached code to whatever end you like, commercial or otherwise.

This work is licensed under a Creative Commons Attribution By license.