Behaviors Library for WPF

In my previous post, Behaviors in WPF with Expression Blend 3, I explained some basics about behaviors with Expression Blend 3. So now, I decided to start working on a library that will combine (hopefully) lots of behaviors for everyday use. I started with several behaviors for Window objects.

Here is what the library contains for now:

• WindowDragMoveBehavior – When attached to a window, this behavior allows the window to be moved with the mouse, but not just by dragging the title bar of the window, as is the default behavior, but by clicking on any point of the window, and then moving the mouse. This is useful when you have skinned apps and you don’t actually have the title bar.
• AnimatedShowHideElementBehavior – Animates the showing or hiding of a framework element (works best for window elements now). Supports several types of animations:
  • Fade In
  • Fade Out
  • Zoom In
  • Zoom Out
  • Skew

Using the library is simple, just add a reference to the .dll file in your project and Expression Blend will start showing the new behaviors in the assets:

Then, just drag and drop the behavior to an element to start using it:

And you’ll see the settings of the behavior in Blend:

Of course, this library is very small now, and i promise that I will add more and more behaviors when I have the time. Any suggestions will be appreciated.

Download the behaviors library

You can download the behaviors library and a small demo project from this link.

Behaviors in WPF with Expression Blend 3

In Expression Blend 3, there is this new cool thing, called behaviors. In very simple words, these are special forms of objects which are attached to another object (usually an element in the UI) and perform some actions thus defining the behavior of the element. The cool thing is that behaviors are reusable, and can be created in libraries and used in many projects. They're not tied to a specific application logic. Another nice thing is that once created, behaviors are extremely easy to attach to an element in XAML.

To demonstrate the power of behaviors, I decided to create a very simple pong-like game ( a game with a ball that is moving around the screen and you have to keep it from escaping) and I used 2 custom behaviors. So let's go through the process.

Getting Started

Creating a custom behaviors is pretty simple. In Expression Blend, go to File -> New Item, and select Behavior.

Then, the code-file of the behavior will be opened. You can edit in Blend of course, but when it comes to writing code, I prefer Visual Studio.

The structure of a behavior
Blend will define a skeleton for your behavior. The most important methods inside are the OnAttached() and the OnDetaching() overrides. As suggested by the name, the OnAttached() method executes when the behavior is being attached to the element, so you should do some initializations there. In the OnDetaching() method, you can provide cleanup. Also in the behavior class you can define properties that control some settings. These properties will be displayed in the Properties section in Expression Blend when the behavior is selected.

The behaviors for my game
In my demo game, I need two types of objects. First type is the player controlled bars (four of them) that move on each side of the screen following the movement of the mouse. The second type is the ball that moves constantly and bounces off the player controlled bars. So as you can guess, I need two behaviors.

So let's see the first behavior I defined. I named it FollowMouseBehavior. Here is the C# code.

using System;
using System.Collections.Generic;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Shapes;
using System.Windows.Interactivity;
using System.ComponentModel;
using Microsoft.Expression.Interactivity.Core;


namespace WpfBehaviorsSample
{
public class FollowMouseBehavior : Behavior<DependencyObject>
{
   // add some private fields
   private Panel parentPanel = null;
   private Window parentWindow = null;

   // add some properties for the behavior
   public bool LockXAxis { get; set; }
   public bool LockYAxis { get; set; }
   public bool IsLimitedToParentPanel { get; set; }
   public bool IsEnabled { get; set; }

   public FollowMouseBehavior()
   {
       this.IsEnabled = true;
       IsLimitedToParentPanel = true;
   }

   protected override void OnAttached()
   {
       base.OnAttached();

       if (!DesignerProperties.GetIsInDesignMode(this) && this.AssociatedObject is UIElement)
       {
           // find the window and the panel in wich the current object is placed
           parentWindow = Common.GetAncestorOfType(this.AssociatedObject, typeof(Window)) as Window;
           parentPanel = Common.GetAncestorOfType(this.AssociatedObject, typeof(Panel)) as Panel;
           if (parentPanel == null || parentWindow == null) return;

           // add a handler for the mouse move event
           parentWindow.PreviewMouseMove += new MouseEventHandler(parentPanel_PreviewMouseMove);
       }
   }

   protected override void OnDetaching()
   {
       base.OnDetaching();

       // Cleanup
       if (!DesignerProperties.GetIsInDesignMode(this) && this.AssociatedObject is UIElement && parentPanel != null)
       {
           parentPanel.PreviewMouseMove -= parentPanel_PreviewMouseMove;
       }
   }



   void parentPanel_PreviewMouseMove(object sender, MouseEventArgs e)
   {
       if (!IsEnabled) return;

       // When the mouse is moved, make the attatched element to follow it

       Point position = e.GetPosition(parentPanel);
  
       if (parentPanel is Canvas)
       {
           double posX = LockXAxis ? Canvas.GetLeft(this.AssociatedObject as UIElement) : position.X;
           double posY = LockYAxis ? Canvas.GetTop(this.AssociatedObject as UIElement) : position.Y;
           if (IsLimitedToParentPanel && this.AssociatedObject is FrameworkElement)
           {
               double pW = parentPanel.ActualWidth;
               double pH = parentPanel.ActualHeight;
               double cW = (this.AssociatedObject as FrameworkElement).ActualWidth;
               double cH = (this.AssociatedObject as FrameworkElement).ActualHeight;

               if (posX > pW - cW) posX = pW - cW;
               if (posY > pH - cH) posY = pH - cH;
           }

           Canvas.SetLeft(this.AssociatedObject as UIElement, posX);
           Canvas.SetTop(this.AssociatedObject as UIElement, posY);
       }
   }

}
}

The code is pretty simple, so I don't think I need to explain it in depth. First of all we find in what window the element is placed, and we add an event handler to this window's mouse move event. Then on mouse move, we just get the mouse coordinates, and change the objects coordinates to follow, according to the settings we defined (for example lock X or Y axis. that causes the element to move only horizontally or vertically, of course it can be moved both horizontally and vertically).

OK, let's look at the second behavior. This will cause an element (in our case, the pong ball) to move around the screen and when it hits another object, to change it's velocity. So this is the MovingBouncingBehavior.

using System;
using System.Collections.Generic;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Shapes;
using System.Windows.Interactivity;
using System.ComponentModel;
using System.Windows.Threading;
using Microsoft.Expression.Interactivity.Core;

namespace WpfBehaviorsSample
{
 public class MovingBouncingBehavior : Behavior<DependencyObject>
 {
     private static Random random = new Random();
     private Panel parentPanel = null;
     private Window parentWindow = null;
     private DispatcherTimer timerAnimation = null;
     private Vector velocity = new Vector(0, 0);

     public double MinVelocityX { get; set; }
     public double MinVelocityY { get; set; }
     public double MaxVelocityX { get; set; }
     public double MaxVelocityY { get; set; }
     public event EventHandler LeftParentBounds;

     public bool IsEnabled { get; set; }

     private TimeSpan animationInterval = TimeSpan.FromMilliseconds(10);
     public TimeSpan AnimationInterval
     {
         get { return animationInterval; }
         set { animationInterval = value; CreateTimer(); }
     }

     public MovingBouncingBehavior()
     {
         AnimationInterval = TimeSpan.FromMilliseconds(10);
         MinVelocityX = 1.0;
         MinVelocityY = 1.0;
         MaxVelocityX = 10.0;
         MaxVelocityY = 10.0;
     }

     protected override void OnAttached()
     {
         base.OnAttached();
         if (!DesignerProperties.GetIsInDesignMode(this) && this.AssociatedObject is UIElement)
         {
             parentWindow = Common.GetAncestorOfType(this.AssociatedObject, typeof(Window)) as Window;
             parentPanel = Common.GetAncestorOfType(this.AssociatedObject, typeof(Panel)) as Panel;
             if (parentPanel == null || parentWindow == null) return;

             velocity = new Vector(GetRandomVelocity(true), GetRandomVelocity(false));
             if (timerAnimation != null) timerAnimation.Start();
         }
     }

     protected override void OnDetaching()
     {
         base.OnDetaching();
         if (!DesignerProperties.GetIsInDesignMode(this) && this.AssociatedObject is UIElement && parentPanel != null)
         {
             if (timerAnimation != null) timerAnimation.Stop();
         }
     }

     private double GetRandomVelocity(bool x)
     {
         if (x)
         {
             return MinVelocityX + random.NextDouble() * (MaxVelocityX - MinVelocityX);
         }
         else
         {
             return MinVelocityY + random.NextDouble() * (MaxVelocityY - MinVelocityY);
         }
     }

     private void CreateTimer()
     {
         if (timerAnimation == null)
         {
             timerAnimation = new DispatcherTimer();
             this.timerAnimation.Tick += new EventHandler(timerAnimation_Tick);
         }
         timerAnimation.Interval = AnimationInterval;
     }

     void timerAnimation_Tick(object sender, EventArgs e)
     {
         if (!IsEnabled) return;
         if (parentPanel is Canvas && this.AssociatedObject is FrameworkElement)
         {
             FrameworkElement ui = this.AssociatedObject as FrameworkElement;
             Point pointNow = new Point(Canvas.GetLeft(ui), Canvas.GetTop(ui));
             Point pointMoved = pointNow + velocity;

             // check for collisions

             bool collisionFound = false;

             int cycleSafetyCounter = 50;
             do
             {
                 cycleSafetyCounter--;
                 pointMoved = pointNow + velocity;
                 Rect rc = new Rect(pointMoved, new Size(ui.ActualWidth, ui.ActualHeight));
                 collisionFound = false;

                 // scan all children of the canvas
                 foreach (UIElement child in parentPanel.Children)
                 {
                     if (child is FrameworkElement && child != ui)
                     {
                         Rect rcChild = new Rect(Canvas.GetLeft(child), Canvas.GetTop(child),
                             (child as FrameworkElement).ActualWidth, (child as FrameworkElement).ActualHeight);
                         if (rcChild.IntersectsWith(rc))
                         {
                             rcChild.Intersect(rc);
                             bool shouldReverseX = random.Next(0, 2) % 2 == 0;
                             bool shouldReverseY = random.Next(0, 2) % 2 == 0;
                             velocity = new Vector(
                                 GetRandomVelocity(true) * (shouldReverseX ? -1 : 1),
                                 GetRandomVelocity(false) * (shouldReverseY ? -1 : 1));
                             collisionFound = true;
                             break;
                         }
                     }
                 }
             }
             while (collisionFound && cycleSafetyCounter > 0);

             Canvas.SetLeft(ui, pointMoved.X);
             Canvas.SetTop(ui, pointMoved.Y);

            if (pointMoved.X < 0 || pointMoved.Y < 0 || pointMoved.X > parentPanel.ActualWidth
                    || pointMoved.Y > parentPanel.ActualHeight)
                {
                    if (LeftParentBounds != null)
                    {
                        LeftParentBounds(this, EventArgs.Empty);
                    }
                }
         }
     }
 }
}

This behavior also has some settings. The ting it does, it creates a timer and then on each tick it moves the element to which it's attached, and checks for collisions. When a collision is found, the velocity is changed. Again, let's not go through the logic, the post is about behaviors, not about making a pong game.

Attaching a behavior to an element
As I said before, attaching behaviors is pretty simple. Now you'll see how it's done.



See? Easy. Just set which behavior to use and change some settings (or, leave the dafault values, of course). Now our element (rectangle in this case) has a behavior. When we run the application and move the mouse, we see that this rectangle moves with it. You can add this behavior to any number of objects, and they'll all behave alike. All that's left to do is attatch the MovingBouncingBehavior to the ball element, edit some brushes (because, the application has to look nice, of course), and run.
Few lines of code, and you have a working game. Pretty powerful things, behaviors.
Thanks for reading. If you want the full demo application, check out the link below.

Download Sample Application

You can download the sample from this link.

Sorting and filtering databound listview in WPF

This is actually quite a simple thing, but a lot of people don't know it, so I'll explain how it's done. As you know, the concept of databinding in WPF is that you provide the visual elements with their data source and they know what to do with it. For example, give a collection of items to a listview, and the listview will generate its items automatically, without forcing you to get involved with the items' visuals, like back at the days of Windows Forms you had to individually create all ListViewItem elements, and so on. On the other hand, that was more direct approach - you know you have some list view items, and when you want to sort them, you just apply sorting to the collection of visual elements. But in WPF you don't have a direct access to the visual elements (ListViewItem). One way to sort a list view would be to modify the source collection. But it's a bit messy, sometimes the collection is read-only, and sometimes we don't want to change the source data.
So WPF offers a way to deal with this with the so called "View" object. It provides functionality to sort, filter, and group items in listviews or other controls that display a collection of items.

Filtering a ListView

Applying a filter to a listview is pretty simple. First, we need to get the view object from the listview, and then provide a predicate that should tell if an item will be included in the filtered view or not.

// Get the default view from the listview
ICollectionView view = CollectionViewSource.GetDefaultView(lstMovies.ItemsSource);

view.Filter = null;
view.Filter = new Predicate<object>(FilterMovieItem);

And now we define the predicate:

private bool FilterMovieItem(object obj)
{
    MovieItem item = obj as MovieItem;
    if (item == null) return false;

    string textFilter = txtFilter.Text;

    if (textFilter.Trim().Length == 0) return true; // the filter is empty - pass all items

    // apply the filter
    if (item.MovieName.ToLower().Contains(textFilter.ToLower())) return true;
    return false;
}

The result is: we now have a working filter for our listview:



Sortinga ListView

The sorting is done in almost the same way. Again we get the view object and then apply some sort descriptions. We don't have to come up with some complicated sorting algorithm, it's enough to provide the property name of the data item by which the listview will be sorted, and the sort direction.

// .....

// Get the default view from the listview
ICollectionView view = CollectionViewSource.GetDefaultView(lstMovies.ItemsSource);

// .....
// .....
    
view.SortDescriptions.Clear();
view.SortDescriptions.Add(new SortDescription(propertyName, direction));

And now we have a support for sorting the items in the listview:



Of course, sorting and filtering can be applied at the same time, like in this case we have filtered movies which have names containing "matrix" and sorted them by rating:



Download sample application

The sample can be downloaded here: Download sample

WPF Circle Launcher User Control and Application

Recently I started developing an user control for WPF which could replace the standard menu systems. The user control is a set of icons, ordered in a circle (or several circles, if there are a lot of icons), and each icon launches some functionality. The user control is customizable, there are parameters for the size of the icons, the radius of the circle, events for clicking and moving, etc.

Then I decided to create a simple application launcher using this control. It's something like a quick-launch menu - users can add shortcuts to applications they use frequently and then start them from there.

Here are some screenshots of the Circle Launcher:


The user control creates animations when the user passes over an icon with the mouse:


It supports transparency and the windows is at the top-level, so it's convenient to use. Also, when the icons become too much for just one circle, the control automatically expands itself.



The application is under development, but still, I decided to post a preliminary version here.
The current features include:

• Adding new icons with drag and drop
• Automatic saving of the icons to XML and then loading back on startup
• Hotkey for showing the launcher - F12
• Moving the launcher across the screen (by dragging the center circle) and saving it's position
• Auto-hide when a shortcut is launched
• Manual hide by double-clicking the center or using the context menu of the system tray icon
  

The features of the user control include:

• Adding and removing shortcuts (Launcher Items)
• Explicitly setting the properties of a shortcut - Name, Icon, Launch path, etc.
• Events for launching, moving, double-click, etc.
• Settings for the circle radius, max number of items in each radius, icon sizes
• Animations
• Built-in drag-drop support for shortcuts
• Support for databinding
  

If anyone is interested in helping me to extend this application or the user control, please contact me. Even only with ideas. Any kind of help will be appreciated.

Download Circle Launcher

You can download the application from here. You'll need .NET 3.5 to run it.

User Control Inheritance in WPF

User control inheritance is very useful in a lot of cases. But it seems like WPF doesn't want us to do that. Have you tried to create a user control (defined with XAML and code-behind) , and then inherit it? The compiler gets very mad at us and says there is an error:

'SomeBaseControl' cannot be the root of a XAML file because it was defined using XAML

Now, what can we do to avoid this unpleasant message?

Variant 1,
Use a custom control for the base class (defined only with code, not XAML)

This is handy sometimes. What you do is create the base control as a custom control, using just the code

public class TestBaseCtrl : Control
{
// Add some base logic here...
}

You can add your controls from the code and create the base logic. Then you can inherit that control even in XAML, like this.



This is a working solution, but it's not very convenient. You don't have the flexibility of XAML in the base control. So let's take a look at the other solution.

Variant 2,
Create the base control using XAML

OK, but how on earth do we do that? We all saw the error message - we cannot define a base control in XAML and then inherit it again in XAML, according to the compiler. However, there is an easy way to trick the compiler to allow us to do that.
The main idea is to create a base control as a custom control again, and then define a control template in XAML. It's basically the same as defining the base control with XAML. Here is what I mean. This is the code-behind for the control:

public class TestBaseCtrl : UserControl
{
 public static RoutedCommand TestButton1 = new RoutedCommand();
 public static RoutedCommand TestButton2 = new RoutedCommand();

 static TestBaseCtrl()
 {
     DefaultStyleKeyProperty.OverrideMetadata(typeof(TestBaseCtrl), new FrameworkPropertyMetadata(typeof(TestBaseCtrl)));
 }

 public TestBaseCtrl()
 {
     this.CommandBindings.Add(new CommandBinding(TestButton1, TestButton1_Executed));
     this.CommandBindings.Add(new CommandBinding(TestButton2, TestButton2_Executed));
 }

 private void TestButton1_Executed(object sender, ExecutedRoutedEventArgs e)
 {
     MessageBox.Show("This is button 1 from the base control");
 }

 private void TestButton2_Executed(object sender, ExecutedRoutedEventArgs e)
 {
     MessageBox.Show("This is button 2 from the base control");
 }
}

And this is the control template, defined in XAML:



You can see that we have specified an area of the base control, in which the content of the child controls would be displayed, using ContentPresenter.
Now, let's inherit that control:



Now, the WPF compiler is totally OK with it, and even displays the inherited control in the designer:

And there you go - now you have a base control and an inherited control which both use the power of XAML. Everything goes well in the compilation and the compiler is no longer mad at us:

========== Build: 1 succeeded or up-to-date, 0 failed, 0 skipped ==========

Download sample application

The sample can be downloaded here: Download sample

Switching WPF interface themes at runtime, Part 2

In my previous post, Switching WPF interface themes at runtime
,I explained how we can easily switch between interface themes at runtime using a simple property and even databinding. That was OK for a single element, or a single window. But what about if we have an application with a lot of windows? Not that hard, just set the property on every window. Yes, that would work, but it has some disadvantages. For example, we change the theme on one window, then we must implement some logic to change it to all other windows that are open, otherwise you are left with windows on the same application with different themes, and that's just ugly. It also can introduce a lot of bugs. And, it is also very boring.

Using a global theme for the application

The idea is that we want to have a theme that should be applied on all of the windows of the application and that can be switched easily at a central location. So I continued working on my ThemeSelector class. I introcuded a property called Global Dictionary, which would be used for all elemenst registered with the theme selector. I also added another attachable property, which is boolean and tells the theme selector whether the element should use the global theme or not.
Let's take a look at the new code:

#region Global Theme

private static List elementsWithGlobalTheme = new List();

private static Uri globalThemeDictionary = null;

public static Uri GlobalThemeDictionary
{
   get { return globalThemeDictionary; }
   set
   {
       globalThemeDictionary = value;

       // apply to all elements registered to use the global theme
       foreach (FrameworkElement element in elementsWithGlobalTheme)
       {
           if (GetApplyGlobalTheme(element))
               ApplyTheme(element, globalThemeDictionary);
       }
   }
}

public static readonly DependencyProperty ApplyGlobalThemeProperty =
   DependencyProperty.RegisterAttached("ApplyGlobalTheme", typeof(bool),
   typeof(MkThemeSelector),
   new UIPropertyMetadata(false, ApplyGlobalThemeChanged));

public static bool GetApplyGlobalTheme(DependencyObject obj)
{
   return (bool)obj.GetValue(ApplyGlobalThemeProperty);
}

public static void SetApplyGlobalTheme(DependencyObject obj, bool value)
{
   obj.SetValue(ApplyGlobalThemeProperty, value);
}


private static void ApplyGlobalThemeChanged(DependencyObject obj, DependencyPropertyChangedEventArgs e)
{
   if (obj is FrameworkElement)
   {
       FrameworkElement element = obj as FrameworkElement;
       if ((bool)e.NewValue)   // if property is changed to 'true', then add to the list of elements and apply theme
       {
           if (!elementsWithGlobalTheme.Contains(element))
               elementsWithGlobalTheme.Add(element);

           // apply the theme
           ApplyTheme(element, GlobalThemeDictionary);
       }
       else
       {
           if (elementsWithGlobalTheme.Contains(element))
               elementsWithGlobalTheme.Remove(element);

           // apply the local theme instead of the global
           ApplyTheme(element, GetCurrentThemeDictionary(element));
       }
   }
}

#endregion

That's all we need. When the ApplyGlobalTheme is set to true on an element, it starts using the global theme. If this is set to false, the element is switched back to the local theme set with the ThemeSelector, or to no theme at all. When the global theme is changed, the code searches all elements that use it and apply the new one. That's not something very complicated but it makes our lives a lot easier. The ApplyTheme(..) method is the same method I used on my previous post, you can look it up there to understand it better. But just in case, I will post it here:

private static void ApplyTheme(FrameworkElement targetElement, Uri dictionaryUri)
{
    if (targetElement == null) return;

    try
    {
        ThemeResourceDictionary themeDictionary = null;
        if (dictionaryUri != null)
        {
            themeDictionary = new ThemeResourceDictionary();
            themeDictionary.Source = dictionaryUri;

            // add the new dictionary to the collection of merged dictionaries of the target object
            targetElement.Resources.MergedDictionaries.Insert(0, themeDictionary);
        }

        // find if the target element already has a theme applied
        List existingDictionaries =
            (from dictionary in targetElement.Resources.MergedDictionaries.OfType()
             select dictionary).ToList();

        // remove the existing dictionaries
        foreach (ThemeResourceDictionary thDictionary in existingDictionaries)
        {
            if (themeDictionary == thDictionary) continue;  // don't remove the newly added dictionary
            targetElement.Resources.MergedDictionaries.Remove(thDictionary);
        }
    }
    finally { }
}

Using the Theme Selector with the global theme

Changing the global theme is easy. Just one line:

      MkThemeSelector.GlobalThemeDictionary = new Uri("/ThemeSelector;component/Themes/ShinyRed.xaml",
          UriKind.Relative);

And that's it. All of the elements that use the global theme will be switched. But how to tell the element that it uses the global theme? Just set the ApplyGlobalTheme attached property to true.

Let's see some screenshots.

This is a two-windows application with the no theme applied.



Let's see what happens when we change the global application theme using the Theme Selector.



Great. Both windows switched their themes. With just only one line of code.

Download Sample

The sample application can be downloaded here.

Switching WPF interface themes at runtime

WPF introduced the use of dynamic resource references. They're very helpful in rich application development. The dynamic resources are loaded at runtime, and can be changed at any time. Dynamic resources could be styles, brushes, etc. WPF however does not provide a convenient way of changing the resource references. That's why I've created a simple class that allows the developers to switch different resources very easy.

Using dynamic resources

Creating and applying a dynamic resource is easy in WPF. First, we need to define the resource:


Then, we have to reference the resource like this:



And that's it. WPF searches for a resource with the given key and applies it when it's found.


Changing the dynamic resources at runtime

As I said, dynamic resources are applied at runtime, that means they can be changed. Let's assume that we have defined several resources like brushes and styles, and we want them to be in two variants - for example a red theme and a blue theme for user interfaces. We put all of the resources for each theme in a different resource dictionary file. For this example, I use the WPF Themes which can be found here: http://wpf.codeplex.com/Wiki/View.aspx?title=WPF%20Themes. So, assume that we have two resource dictionaries:

ShinyBlue.xaml
ShinyRed.xaml

Without these themes, a WPF window should look something like this:



Using the themes is pretty easy, all we need to do is merge one of the resource dictionary to the resources of root control or window:



And now, the window looks like that:



Pretty neat, huh? OK, that's good, but what if we want to change the theme to the red one? We have to go in the XAML code, change the source of the merged resource dictionary and recompile. No way! We should be able to come up with something nicer.

Well, there's a solution. See, everytime when the resources of a framework element are changed (added or removed resources), WPF goes through all elements with dynamic resource references and updates them accordingly. So the solution should be obvious - when we need to change the theme, we can simply remove the old merged dictionary, and add the new one. I searched a bit in the internet, and the most common solution is to clear all merged dictionaries from the collection and then add the desired one. Yes, allright, that would work. But what if the developer has added more than one resource dictionary, not only the one with the theme resources? Everything goes away, and bang, the software is not working. So there should be a proper way of detecting which resource dictionary contains the theme resources, and leave the other dictionaries alone.

It sounds a bit complicated, right? First, search for the right resource dictionary, then remove it from the list of merged dictionaries, then load the new one, and apply it. Yes but what if it could be done jyst by setting one single value to one signle property, and all is OK?

The ThemeSelector class

So there is it. The solution. I created a class which has an attachable property - the URI path to the desired theme dictionary. Now, let's think about finding the right dictionary to be removed when themes are being switched. Kinda obvious solution is a new class that inherits ResourceDictionary. Then, we search all merged dictionaries and remove those which are of this new type. Pretty simple, right? Here's the class:

public class ThemeResourceDictionary : ResourceDictionary
{
}

So it's time to see the real deal.

public class MkThemeSelector : DependencyObject
{

public static readonly DependencyProperty CurrentThemeDictionaryProperty =
 DependencyProperty.RegisterAttached("CurrentThemeDictionary", typeof(Uri),
 typeof(MkThemeSelector),
 new UIPropertyMetadata(null, CurrentThemeDictionaryChanged));

public static Uri GetCurrentThemeDictionary(DependencyObject obj)
{
 return (Uri)obj.GetValue(CurrentThemeDictionaryProperty);
}

public static void SetCurrentThemeDictionary(DependencyObject obj, Uri value)
{
 obj.SetValue(CurrentThemeDictionaryProperty, value);
}

private static void CurrentThemeDictionaryChanged(DependencyObject obj, DependencyPropertyChangedEventArgs e)
{
 if (obj is FrameworkElement) // works only on FrameworkElement objects
 {
     ApplyTheme(obj as FrameworkElement, GetCurrentThemeDictionary(obj));
 }
}

private static void ApplyTheme(FrameworkElement targetElement, Uri dictionaryUri)
{
 if (targetElement == null) return;

 try
 {
     ThemeResourceDictionary themeDictionary = null;
     if (dictionaryUri != null)
     {
         themeDictionary = new ThemeResourceDictionary();
         themeDictionary.Source = dictionaryUri;

         // add the new dictionary to the collection of merged dictionaries of the target object
         targetElement.Resources.MergedDictionaries.Insert(0, themeDictionary);
     }

     // find if the target element already has a theme applied
     List existingDictionaries =
         (from dictionary in targetElement.Resources.MergedDictionaries.OfType()
          select dictionary).ToList();

     // remove the existing dictionaries
     foreach (ThemeResourceDictionary thDictionary in existingDictionaries)
     {
         if (themeDictionary == thDictionary) continue;  // don't remove the newly added dictionary
         targetElement.Resources.MergedDictionaries.Remove(thDictionary);
     }
 }
 finally { }
}
}

As I said, the class as one dependency property and an callback method to handle the event of changing the value of this property. There everything is straight-forward. First, the new theme dictionary is loaded, and then the old one is removed. That's it.

Using the ThemeSelector class

Here comes the nice part. The usage of the class is as simple as changing the value of one single property.

        private void ChangeToRedTheme()
{
    MkThemeSelector.SetCurrentThemeDictionary(this, new Uri("/ThemeSelector;component/Themes/ShinyRed.xaml", UriKind.Relative));
}

When this method is called, the theme changes:


The ThemeSelector class and WPF data binding

We can even use databinding to change the themes dynamically. Let's assume that we have a combo box which have two items - the red theme, and the blue theme:


Now, on the element to which we want to apply the theme, for example the root grid in the window, we set the following binding expression:
local:MkThemeSelector.CurrentThemeDictionary="{Binding ElementName=cmbThemes, Path=SelectedItem.Tag}"

So it looks like this:


And that's all. When we run the application, we have this combo box, allowing us to select the theme in runtime.



Download sample application

The sample can be downloaded here: Download sample

CodeProject

Using GPU-Accelerated shader effects in WPF

by Svetoslav Savov

With Service Pack 1 of .NET 3.5 the use of effects in WPF was significantly improved. The old so called “bitmap effects” were using the CPU to render the visual elements. As a result, when a BitmapEffect is used, the whole visual tree of the element on which it’s applied becomes software rendered. As you can imagine, this dramatically decreases the performance of the user interface, especially when you add animations or 3D scenes. The new effects are using the DirectX shader system and they are rendered using the graphical processor which is a lot faster when it comes to calculating pixels, and also it relieves the CPU of the time-consuming effect operations so it is free to perform other tasks. With Effects you can combine the programmability of the GPU and the flexible environment of WPF to create rich user interfaces with animations, data binding and 3D scenes.

What do you need?

For developing a WPF application with shader effects you need several things:

• .NET 3.5 SP1 (of course :) )

http://www.microsoft.com/downloads/details.aspx?FamilyID=ab99342f-5d1a-413d-8319-81da479ab0d7&displaylang=en

• DirectX SDK for the development stage

http://www.microsoft.com/downloads/details.aspx?FamilyID=ea4894b5-e98d-44f6-842d-e32147237638&displaylang=en

• A tool to create the effects

The Shazzam Tool is a great tool for this - http://shazzam-tool.com

Getting started with Shazzam

First of all we can take a look at Shazzam. It comes with some sample shaders we can use for learning.

Start Shazzam and go to Shader Loader -> Sample Shaders.

You can see the shader’s FX file, and a sample image which will be used to review and test the effect. Click on Tools->Compile Shader or press F7. Then click on Tools->Apply Shader (F5). When the shader is compiled you can see that Shazzam generated a C# class and a Visual Basic class that wrap the effect’s properties.

Also the Change Shader Settings page appeared. There you can see all the changeable properties of the effect and see in real time what happens when you change a property. To test the effect you can use one of the built-in sample images or you can select another.

Let’s try something out. Select the Pixelate.fx shader from the samples. Choose the first sample image (Sample1). Compile (F7) and Apply (F5) the effect. What happened? The image seems to have disappeared. That’s because the properties of the shader have default values of zero, and that just doesn’t work for our effect.

In the settings page, you can see some text boxes and sliders. They are used for changing the properties of the effect. First of all, you can see that there are a Min and a Max boxes with default values of 0 and 1. We have to change them to actually see the effect working. That’s because the system cannot know what the property is being used for, it doesn’t make any sense, it’s just a value. So the developers of Shazzam decided that the default values can be from 0 to 1. But in the case of Pixelate effect, the parameter values are in pixels. So we need to change them to 0-600 for both Horizontal pixel counts and Vertical pixel counts. And now when we move the sliders, we change the values from 0 to 600 instead of from 0 to 1. Now it makes sense.

So let’s change the values to about 100.

As we move the slider we can actually see what’s happening in the image above.

You can try some other effects from the samples, or browse the internet for third-party shaders. There are some nice video tutorials on Shazzam website, http://shazzam-tool.com.

Using effects in a WPF application

Adding the effect to a WPF project

The integration of a shader effect in WPF application is a relatively simple task.

First of all, it’s probably a good idea to add the compiled shader file to our WPF project. In Shazzam, go to the Tools menu and click on View Compiled Shaders. There are all the effects that we have compiled using Shazzam. In Visual Studio, select the project and right-click on it, choose Add New -> Existing Item and select the compiled effect file (the files are with .ps extension). Right click on the file in Solution Explorer and select Properties. Set the Build Action parameter to Resource.

Create a new code file, go to Shazzam, copy the auto-generated class code, and paste it in the new code file. You will see some dependency properties, and a constructor. So let’s take a look at the constructor.

public AutoGenShaderEffect(PixelShader shader) {

// Note: for your project you must decide how to use the generated ShaderEffect class (Choose A or B below).

// A: Comment out the following line if you are not passing in the shader and remove the shader parameter from the constructor

PixelShader = shader;

// B: Uncomment the following two lines - which load the *.ps file

// Uri u = new Uri(@"pack://application:,,,/bandedswirl.ps");

// PixelShader = new PixelShader() { UriSource = u };

// Must initialize each DependencyProperty that's affliated with a shader register

// Ensures the shader initializes to the proper default value.

this.UpdateShaderValue(InputProperty);

this.UpdateShaderValue(HorizontalpixelcountsProperty);

this.UpdateShaderValue(VerticalpixelcountsProperty);

}

It’s very well commented and it practically tells us what to do. As we can see, there are two cases for using the effect class. First one is to pass the pixel shader as a parameter to the constructor. The second one is to create the pixel shader directly there. In this example, we choose option B – create the PixelShader object directly in the constructor. So we remove the line

PixelShader = shader;

and uncomment the lines for creating the object. Also It’s a good idea to rename the class so that we can recognize it later. The default name is AutoGenShaderEffect which is not very intuitive. But when you change the name of the class, don’t forget to change the owner type of the dependency properties.

So with all the changes our class looks something like this:

public PixelateShaderEffect()

{

Uri u = new Uri("/PixelShaders;component/EffectPS/Pixelate.ps", UriKind.Relative);

PixelShader = new PixelShader() { UriSource = u };

this.UpdateShaderValue(InputProperty);

this.UpdateShaderValue(HorizontalpixelcountsProperty);

this.UpdateShaderValue(VerticalpixelcountsProperty);

}

And that’s it. We now have a class that represents the pixel shader effect.

Using the effect in user interface

Now that we have the effect created in our project, we finally can see it in action in our user interface. Let’s create some demo interface, nothing special, just to see the effect.

I created something like this, just for fun:

And here’s the XAML code:

<Grid>

<Grid.ColumnDefinitions>

<ColumnDefinition Width="100" />

<ColumnDefinition />

Grid.ColumnDefinitions>

<StackPanel>

<Button x:Name="btnTest1" Content="Button One" Margin="2"/>

<Button x:Name="btnTest2" Content="Hack NASA" Margin="2"/>

<Button x:Name="btnTest3" Content="Go to the moon" Margin="2"/>

<Button x:Name="btnTest4" Content="Crash app" Margin="2"/>

StackPanel>

<TextBlock Grid.Column="1" Text="Some programming languages are so good that a program written with them can go through an infinite loop for about ten minutes on really fast computers."

TextWrapping="Wrap" Margin="10" Foreground="Blue"/>

<Canvas Grid.Column="1" Width="100" Height="100">

<Ellipse Width="100" Height="100" Fill="Yellow" Stroke="Black"/>

<Ellipse Width="25" Height="25" Fill="Black" Canvas.Left="20" Canvas.Top="20" />

<Ellipse Width="25" Height="25" Fill="Black" Canvas.Left="55" Canvas.Top="20" />

<Ellipse Width="60" Height="40" Fill="Black" Canvas.Left="20" Canvas.Top="45" />

<Ellipse Width="60" Height="36" Fill="Yellow" Canvas.Left="20" Canvas.Top="44" />

Canvas>

Grid>

So, let’s apply our effect.

Add a namespace reference to the shader class in the XAML code, something like this:

xmlns:sh="clr-namespace:Shazzam.Shaders"

Set the effect for the root grid:

<Grid.Effect>

<sh:PixelateShaderEffect

Horizontalpixelcounts="200"

Verticalpixelcounts="200"/>

Grid.Effect>

Now, we run the application and see what happens:

Nice! The effect was applied. That’s it. Simple, right?

Things to play with

Testing effects in real time in the application interface

Just for fun, I continued working on my shader effects demo application. I added two sliders that can control the effect, just like it was in Shazzam. Only, this works on a real application interface, so it’s more interesting.

<Grid>

<Grid.ColumnDefinitions>

<ColumnDefinition Width="40" />

<ColumnDefinition />

Grid.ColumnDefinitions>

<Grid.RowDefinitions>

<RowDefinition />

<RowDefinition Height="40"/>

Grid.RowDefinitions>

<Grid Grid.Column="1">

<Grid.ColumnDefinitions>

<ColumnDefinition Width="100" />

<ColumnDefinition />

Grid.ColumnDefinitions>

<StackPanel>

<Button x:Name="btnTest1" Content="Button One" Margin="2"/>

<Button x:Name="btnTest2" Content="Hack NASA" Margin="2"/>

<Button x:Name="btnTest3" Content="Go to the moon" Margin="2"/>

<Button x:Name="btnTest4" Content="Crash app" Margin="2"/>

StackPanel>

<TextBlock Grid.Column="1" Text="Some programming languages are so good that a program written with them can go through an infinite loop for about ten minutes on really fast computers."

TextWrapping="Wrap" Margin="10" Foreground="Blue"/>

<Canvas Grid.Column="1" Width="100" Height="100">

<Ellipse Width="100" Height="100" Fill="Yellow" Stroke="Black"/>

<Ellipse Width="25" Height="25" Fill="Black" Canvas.Left="20" Canvas.Top="20" />

<Ellipse Width="25" Height="25" Fill="Black" Canvas.Left="55" Canvas.Top="20" />

<Ellipse Width="60" Height="40" Fill="Black" Canvas.Left="20" Canvas.Top="45" />

<Ellipse Width="60" Height="36" Fill="Yellow" Canvas.Left="20" Canvas.Top="44" />

Canvas>

<Grid.Effect>

<sh:PixelateShaderEffect

Horizontalpixelcounts="{Binding ElementName=slHori, Path=Value}"

Verticalpixelcounts="{Binding ElementName=slVert, Path=Value}"/>

Grid.Effect>

Grid>

<Slider x:Name="slHori" Minimum="10" Maximum="500" Value="500" Grid.Row="1" Grid.Column="1"/>

<Slider x:Name="slVert" Minimum="10" Maximum="500" Value="500" Orientation="Vertical" />

Grid>

Animating the shader effects

Animating the effects is very simple. Just like any other animation in WPF.

<Window.Resources>

<Storyboard x:Key="effectStory" >

<DoubleAnimation Storyboard.TargetName="shaderEffect"

Storyboard.TargetProperty="Horizontalpixelcounts"

From="10" To="500" Duration="0:0:10" AutoReverse="True" RepeatBehavior="Forever"/>

<DoubleAnimation Storyboard.TargetName="shaderEffect"

Storyboard.TargetProperty="Verticalpixelcounts"

From="10" To="500" Duration="0:0:10" AutoReverse="True" RepeatBehavior="Forever"/>

Storyboard>

Window.Resources>

Other shader effects

Motion Blur:

<sh:DirectionalBlurShaderEffect Bluramount="0.005" Angle="45" />

Embossed

<sh:EmbossedShaderEffect Width="0.002" Amount="0.5" />

Download Sample

You can download the sample application here: Download Sample