Christian Moser's WPF Tutorial.net

RadioButton

moc@zuehlke.com (Christian Moser) — Fri, 03 Sep 2010 15:42:53 +02002010-08-26 20:42:54

Radio Button

Introduction

The RadioButton control has its name from old analog radios which had a number of programmable station buttons. When you pushed one in, the previosly selected poped out. So only one station can be selected at a time.

The RadioButton control has the same behavior. It lets the user choose one option out of a few. It the list of options gets longer, you should prefer a combo or list box instead.

To define which RadioButtons belong togehter, you have to set the GroupName to the same name.

To preselect one option set the IsChecked property to True.

 
<StackPanel>
    <RadioButton GroupName="Os" Content="Windows XP" IsChecked="True"/>
    <RadioButton GroupName="Os" Content="Windows Vista" />
    <RadioButton GroupName="Os" Content="Windows 7" />
    <RadioButton GroupName="Office" Content="Microsoft Office 2007" IsChecked="True"/>
    <RadioButton GroupName="Office" Content="Microsoft Office 2003"/>
    <RadioButton GroupName="Office" Content="Open Office"/>
</StackPanel>

How to DataBind Radio Buttons in WPF

The radio button control has a known issue with data binding. If you bind the IsChecked property to a boolean and check the RadioButton, the value gets True. But when you check another RadioButton, the databound value still remains true.

The reason for this is, that the Binding gets lost during the unchecking, because the controls internally calls ClearValue() on the dependency property.

 
<Window.Resources>
   <EnumMatchToBooleanConverter x:Key="enumConverter" />
</Window.Resources>
 
 
<RadioButton Content="Option 1" GroupName="Options1" 
             IsChecked="{Binding Path=CurrentOption, Mode=TwoWay, 
                                 Converter={StaticResource enumConverter},
                                 ConverterParameter=Option1}"  />
<RadioButton Content="Option 2" GroupName="Options2" 
             IsChecked="{Binding Path=CurrentOption, Mode=TwoWay, 
                                 Converter={StaticResource enumConverter},
                                 ConverterParameter=Option2}"  />
<RadioButton Content="Option 3" GroupName="Options3" 
             IsChecked="{Binding Path=CurrentOption, Mode=TwoWay, 
                                 Converter={StaticResource enumConverter},
                                 ConverterParameter=Option3}"  />

 
public class EnumMatchToBooleanConverter : IValueConverter
    {
        public object Convert(object value, Type targetType, 
                              object parameter, CultureInfo culture)
        {
            if (value == null || parameter == null)
                return false;
 
            string checkValue = value.ToString();
            string targetValue = parameter.ToString();
            return checkValue.Equals(targetValue, 
                     StringComparison.InvariantCultureIgnoreCase);
        }
 
        public object ConvertBack(object value, Type targetType, 
                                  object parameter, CultureInfo culture)
        {
            if (value == null || parameter == null)
                return null;
 
            bool useValue = (bool)value;
            string targetValue = parameter.ToString();
            if (useValue)
                return Enum.Parse(targetType, targetValue);
 
            return null;
        }
    }

Triggers

moc@zuehlke.com (Christian Moser) — Fri, 03 Sep 2010 15:42:54 +02002010-07-30 12:01:51

Triggers in Styles

Triggers define a list of setters that are executed if the specified condition is fulfilled. WPF knows tree diferent types of triggers

Property Triggers execute when a property gets a specified value.
Event Triggers execute when a specified event is fired.
Data Triggers execute when a binding expression reaches a specified value.

Property Triggers

A property trigger executes a list of setters when a property gets a specified value. If the value changes the trigger undoes the setters.

 
<Style x:Key="styleWithTrigger" TargetType="Rectangle">
    <Setter Property="Fill" Value="LightGreen" />
    <Style.Triggers>
        <Trigger Property="IsMouseOver" Value="True">
            <Setter Property="Fill" Value="Red" />
        </Trigger>
    </Style.Triggers>
</Style>
 
<Rectangle Style="{StaticResource styleWithTrigger}"></Rectangle>

Event Triggers

Data Triggers

Multi Triggers

Trick to use triggers everywhere

Triggers are only available in styles and templates. Even if every control has a property Triggers, it only works with EventTriggers. If you want to use normal triggers outside a style or a template, you can use a little trick. Just wrap your code with the following snippet:

 
<Control>
    <Control.Template>
        <ControlTemplate>
            <!-- Triggers are available here -->
        </ControlTemplate>
    </Control.Template>
</Control>

WPF Inspector

moc@zuehlke.com (Christian Moser) — Fri, 03 Sep 2010 15:42:54 +02002010-07-29 21:11:13

Download WPF Inspector and get the insight!

Download WPF Inspector 0.9.5 (Beta)

My motivation

While developing WPF applications I often had difficulties to see what is excatly going on in there. What is the DataContext of a particular element? Why is that data binding not working? On what element do I have binding errors? Why is this trigger not active?. I wanted to build a tool that helps me in my daily work to get around this typical issues...

There are some pretty powerful tools out there that do a good job, like Snoop or Mole. But I wanted to add some more functionality. So I started the "WPF Inspector" project.

It's still a bit buggy and can cause some side effects while inspecting your application, but I think its really helpful and time to share.

Just download it and try it out. If you have any feedback or feature requests, feel free to contact me.

Start to inspect an application

Start the WPF inspector from your startmenu. WPF Inspecor will automatically list all running 32-bit and 64-bit WPF applications. Double click on one, or choose "inspect" to start the inspection.

Browse the logical and visual tree

After the inspector has been sucessfully hooked into your application, a window opens, that shos you the elements of your application. You can navigate through the visual and logical tree and see properties, datacontext, resources and triggers.

Find elements directly in the application

You can use the mouse to hover over the inspecting application by holding the CTRL key pressed to automatically select the element below the mouse. A red or blue outline indicates the selected element, depending if you are have the visual or the logical tree browser active.

See what's in the DataContext

By using the WPF Inspector it's very easy to see what data structure is inherited to a specific element by the data context. Just select the element and switch to the DataContext tab. You can even change editable values from your data model.

Debug Triggers

Triggers are a very flexible and powerful thing, but they are event hard to debug. WPF Inspector allows you to directly see all conditions and values of a trigger and check if he is currently active or not. This makes life a lot easier!

Check your application against prooven WPF design principles

WPF Inspector includes a set or rules that check your application against some design principles. The rules are divided into the categories functionality, performance and maintainability. The found issues are categorizes into tree levels of severity. My favorite rule is the databinding error checker. It shows you excactly what property on what element failed to bind!

Version History

WPF Inspector 0.9.5
- Fixed issue with logical tree selection
- Improved adorner for grids
- Added property editor for GridLengths
- Fixed issue with theming
WPF Inspector 0.9.4
- Fixed layout recursion issue
- Application Theme switcher
- Size changer (resize to common sizes)
- Highlighting of changed properties
- Breakpoints on property changes
- Style explorer
- Lot of bugfixes
WPF Inspector 0.9.3
- Re-evaluating rules when a value changed
- Refactored rule engine
- Performance improvements
WPF Inspector 0.9.2
- Fixed some styling issues
- Added Introduction Dialog on first starup
- Changed installer package type to 32-bit

Debugging Animations

moc@zuehlke.com (Christian Moser) — Fri, 03 Sep 2010 15:42:54 +02002010-07-28 14:21:16

Debugging style and template Errors

Common Errors

If you get the following error: Cannot animate ... on an immutable object instance. it could be that you are run into one of the following issues:

You are animating a dependency property without having a value set
You are animating a dependency property who's current value is defined in another assembly that is not merged into the resource dictionary.
You are animating a value that is currently databound
You have an invalid property path specified.

Home

moc@zuehlke.com (Christian Moser) — Fri, 03 Sep 2010 15:42:54 +02002010-07-28 12:05:20

Welcome to the WPF Tutorial

Welcome to my website about the Windows Presentation Foundation. The tutorials will show you how to create the next generation user experience. I hope you will get amazed by the possibilities of this fascinating technology.

[news]

[tipofday] [popular]

Third Party Controls

moc@zuehlke.com (Christian Moser) — Fri, 03 Sep 2010 15:42:54 +02002010-07-22 08:35:24

WPF - Third Party Controls

WPF Component Vendors

Data Grids

Charts

Dialogs

Pure WPF FileOpen, FileSave and FolderBrowser Dialogs

Dock

Editors

Effects

Transitionals - Framework to transition between screens.

GIS and Maps

Multimedia

Misc

Outlook Bar

Panels

Reporting

Ribbon

Toolbar

Theming

WPF Theme Selector

Tree

Telerik RadTree View for WPF

Schedule

3D

Xceed 3D Views

Web Browser

Chromium Web Browser

Menus

moc@zuehlke.com (Christian Moser) — Fri, 03 Sep 2010 15:42:54 +02002010-07-21 10:14:30

Menus in WPF

MenuItem

The MenuItem is a HeaderedItemsControl. The content of the Header property is the caption of the menu. The Items of a MenuItems are its sub menus. The Icon property renders a second content on the left of the caption. This is typically used to draw a little image. But it can be used for type of content.

You can define a keyboard shortcut by adding an underscore in front of a character.

 
<MenuItem Header="_Edit">
    <MenuItem Header="_Cut" Command="Cut">
        <MenuItem.Icon>
            <Image Source="Images/cut.png" />
        </MenuItem.Icon>
    </MenuItem>
    <MenuItem Header="_Copy" Command="Copy">
        <MenuItem.Icon>
            <Image Source="Images/copy.png" />
        </MenuItem.Icon>
    </MenuItem>
    <MenuItem Header="_Paste" Command="Paste">
        <MenuItem.Icon>
            <Image Source="Images/paste.png" />
        </MenuItem.Icon>
    </MenuItem>
</MenuItem>

Checkable MenuItems

You can make a menu item checkable by setting the IsCheckable property to true. The check state can be queried by the IsChecked property. To get notified when the check state changes you can add a handler to the Checked and Unchecked property.

 
<MenuItem Header="_Debug">
    <MenuItem Header="Enable Debugging" IsCheckable="True" />
</MenuItem>

Separators

Separator is a simple control to group menu items. It's rendered as a horizontal line. It can also be used in ToolBar and StatusBar.

 
<Menu>
    <MenuItem Header="_File">
        <MenuItem Header="_New..." />
        <Separator />
        <MenuItem Header="_Open..." />
        <Separator />
        <MenuItem Header="_Save" />
        <MenuItem Header="_Save As..." />
        <Separator />
        <MenuItem Header="_Exit" />
    </MenuItem>
</Menu>

Callbacks

You can register a callback to any menu item by adding a callback to the Click event.

 
<Menu>
    <MenuItem Header="_File">
        <MenuItem Header="_New..."  Click="New_Click"/>
    </MenuItem>
</Menu>

 
private void New_Click(object sender, RoutedEventArgs e)
{
    MessageBox.Show("You clicked 'New...'");
}

How to bind MenuItems dynamically using MVVM

If you are using the model-view-viewmodel pattern, you probably want to define the available menu command dynamically in your code and then bind them to a MenuItem control. The following sample shows you how to do this:

 
<Menu>
    <Menu.Resources>
        <Style x:Key="ThemeMenuItemStyle" TargetType="MenuItem">
           <Setter Property="Header" Value="{Binding Name}"></Setter>
           <Setter Property="Command" Value="{Binding ActivateCommand}"/>
           <Setter Property="IsChecked" Value="{Binding IsActive}" />
           <Setter Property="IsCheckable" Value="True"/>
        </Style>
    </Menu.Resources>
    <MenuItem Header="Themes" ItemsSource="{Binding Themes}" 
              ItemContainerStyle="{StaticResource ThemeMenuItemStyle}"  />
</Menu>

Keyboard Shortcuts

To add a keyboard shortcut to a menu item, add a underscode "_" in front of the caracter you want to use as your hot key. This automatically sets the InputGestureText to an appropriate value. But you can also override the proposed text by setting this property to a text of your choice.

Books

moc@zuehlke.com (Christian Moser) — Fri, 03 Sep 2010 15:42:54 +02002010-07-21 08:47:41

Books about WPF

Brand New!

WPF 4 - Unleashed

In my opinion one of the best books about WPF - now updated to version 4.0. It's printed fully in color, so all code samples have syntax highlighting. It includes all the good explanations and samples of version 3 including new chapters about multitouch, XAML 2009, VSM, improved text rendering, windows 7 shell integration and more.

Autor:	Adam Nathan
ISBN:	978-0672331190
Published:	June 2010
	Find it at Amazon

WPF Control Development Unleashed

In this book, two leading Windows Presentation Foundation experts give developers everything they need to build next-generation WPF applications--software that is more robust, usable, and compelling. Drawing on their close ties with Microsoft's WPF development team, Pavan Podila and Kevin Hoffman give you a clear, robust, and practical understanding of WPF, its underpinnings, its overall architecture, and its design philosophy.

Autor:	Pavan Podila, Kevin Hoffman
ISBN:	978-0672330339
Published:	September 2009
	Find it at Amazon

Windows Presentation Foundation - Unleashed (My favorite!)

In my opinion one of the best book about WPF. It covers all important themes including 3D programming. All code samples have syntax highlighting. Digging deeper sections with additional informations for advanced programmers.

Autor:	Adam Nathan
ISBN:	978-0672328916
Published:	January 2007
	Find it at Amazon

Application = Code + Markup

"Get the definitive guide to the Windows Presentation Foundation (WPF), the new client programming interface for the Microsoft .NET Framework 3.0 and Windows Vista. Award-winning author Charles Petzold teaches you how to combine C# code and the Extensible Application Markup Language (XAML) to develop applications for the WPF.". I cannot unterstand how anyone can write a book about a UI technology without a single illustration. If you prefer gray text to colorful images, it might be the book for you.

Autor:	Charles Petzold
ISBN:	978-0735619579
Published:	August 2006

Essential Windows Presentation Foundation

Chris Anderson was one of the chief architects of the next-generation GUI stack, the Windows Presentation Framework (WPF), which is the subject of this book. Chris's insights shine a light from the internals of WPF to those standing at the entrance, guiding you through the concepts that form the foundation of his creation.

Autor:	Chris Anderson
ISBN:	978-0321374479
Published:	April 2007

Foundations of WPF: An Introduction to Windows Presentation Foundation

Foundations of WPF: An Introduction to Windows Presentation Foundation teaches you everything you need to get started with the technology, and is broken into three parts. The first introduces and contextualizes the WPF technology; the second part dives deeper into the facets of the technology that are of immediate and valuable use in developing applications; the last part offers you the real-world perspective you need to be productive in the community and customer base.

Autor:	Laurence Moroney
ISBN:	978-1590597606
Published:	November 2006

Pro WPF in C# 2008

This book explains how WPF works from the ground up. It follows on from the author s previous and highly successful books, covering Windows Forms (WPF's predecessor technology) and earlier versions of WPF. It is a one-stop shop in Apress proven Pro style that leaves readers with a deep understanding of the technology and able to take the concepts away and apply them for themselves.

Autor:	Matthew McDonald
ISBN:	978-1590599556
Published:	Februar 2008

Foundations of WPF: An Introduction to Windows Presentation Foundation

If you want to build applications that take full advantage of Windows Vista's new user interface capabilities, you need to learn Microsoft's Windows Presentation Foundation (WPF). This new edition, fully updated for the official release of .NET 3.0, is designed to get you up to speed on this technology quickly.

Autor:	Chris Sells and Ian Griffiths
ISBN:	978-0596510374
Published:	September 2007

XAML Editors

moc@zuehlke.com (Christian Moser) — Fri, 03 Sep 2010 15:42:54 +02002010-07-15 15:45:08

XAML Editors

Inline Images in a FlowDocument

moc@zuehlke.com (Christian Moser) — Fri, 03 Sep 2010 15:42:54 +02002010-07-15 08:22:33

How to inline Images in a FlowDocument

Introduction

Sometimes you want to deploy, share or load just a plain XAML file containing a FlowDocument. Then you want to put in some inline images. HTML provides a functionality to express the image as Base64 encoded CDATA section, but WPF does not have such a functionality.

I found a solution how to do this, by creating a custom InlineImage element, that does the trick. The following example shows how to do it.

 
<FlowDocument>
    <InlineImage Width="100" Height="100" Stretch="Fill">
        <![CDATA[iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAB3RJTUUH2AQP
        SFlzAAALEgAACxIB0t1+/AAAAARnQU1BAACxjwv8YQUAAAnOSURBVHjaxVcLcBvVFT1vV
        ki3Hju3GCQnGjkObONQkJkxCSIHQQGnIdEr5TFs+LaGl7RRCSUvDp8nglH4mDGQ6EwZIm=]]>
    </InlineImage>
</FlowDocument>

Implementation of the InlineImage Control

 
namespace XamlInlineImageDemo
{
 
[assembly: XmlnsDefinition("http://schemas.microsoft.com/winfx/2006/xaml/presentation",
 "XamlInlineImageDemo")]
 
[ContentProperty("Base64Source")]
public class InlineImage : BlockUIContainer
{
    #region DependencyProperty 'Width'
 
    /// <summary>
    /// Gets or sets the width.
    /// </summary>
    public double Width
    {
        get { return (double)GetValue(WidthProperty); }
        set { SetValue(WidthProperty, value); }
    }
 
    /// <summary>
    /// Registers a dependency property to get or set the width
    /// </summary>
    public static readonly DependencyProperty WidthProperty =
        DependencyProperty.Register("Width", typeof(double),
        typeof(InlineImage),
        new FrameworkPropertyMetadata(Double.NaN));
 
    #endregion
 
    #region DependencyProperty 'Height'
 
    /// <summary>
    /// Gets or sets the height.
    /// </summary>
    public double Height
    {
        get { return (double)GetValue(HeightProperty); }
        set { SetValue(HeightProperty, value); }
    }
 
    /// <summary>
    /// Registers a dependency property to get or set the height
    /// </summary>
    public static readonly DependencyProperty HeightProperty =
        DependencyProperty.Register("Height", typeof(double),
        typeof(InlineImage),
        new FrameworkPropertyMetadata(Double.NaN));
 
    #endregion
 
    #region DependencyProperty 'Stretch'
 
    /// <summary>
    /// Gets or sets the stretch behavior.
    /// </summary>
    public Stretch Stretch
    {
        get { return (Stretch)GetValue(StretchProperty); }
        set { SetValue(StretchProperty, value); }
    }
 
    /// <summary>
    /// Registers a dependency property to get or set the stretch behavior
    /// </summary>
    public static readonly DependencyProperty StretchProperty =
        DependencyProperty.Register("Stretch", typeof(Stretch),
        typeof(InlineImage),
        new FrameworkPropertyMetadata(Stretch.Uniform));
 
    #endregion
 
    #region DependencyProperty 'StretchDirection'
 
    /// <summary>
    /// Gets or sets the stretch direction.
    /// </summary>
    public StretchDirection StretchDirection
    {
        get { return (StretchDirection)GetValue(StretchDirectionProperty); }
        set { SetValue(StretchDirectionProperty, value); }
    }
 
    /// <summary>
    /// Registers a dependency property to get or set the stretch direction
    /// </summary>
    public static readonly DependencyProperty StretchDirectionProperty =
        DependencyProperty.Register("StretchDirection", typeof(StretchDirection), 
        typeof(InlineImage), 
        new FrameworkPropertyMetadata(StretchDirection.Both));
 
    #endregion
 
    #region DependencyProperty 'Base64Source'
 
    /// <summary>
    /// Gets or sets the base64 source.
    /// </summary>
    public string Base64Source
    {
        get { return (string)GetValue(Base64SourceProperty); }
        set { SetValue(Base64SourceProperty, value); }
    }
 
    /// <summary>
    /// Registers a dependency property to get or set the base64 source
    /// </summary>
    public static readonly DependencyProperty Base64SourceProperty =
        DependencyProperty.Register("Base64Source", typeof(string), typeof(InlineImage),
        new FrameworkPropertyMetadata(null, OnBase64SourceChanged));
 
    #endregion
 
    #region Private Members
 
    private static void OnBase64SourceChanged(DependencyObject sender, 
        DependencyPropertyChangedEventArgs e)
    {
        var inlineImage = (InlineImage)sender;
        var stream = new MemoryStream(Convert.FromBase64String(inlineImage.Base64Source));
 
        var bitmapImage = new BitmapImage();
        bitmapImage.BeginInit();
        bitmapImage.StreamSource = stream;
        bitmapImage.EndInit();
 
        var image =new Image {
            Source = bitmapImage, 
            Stretch = inlineImage.Stretch,
            StretchDirection = inlineImage.StretchDirection,
             };
 
        if (!double.IsNaN(inlineImage.Width))
        {
            image.Width = inlineImage.Width;
        }
 
        if (!double.IsNaN(inlineImage.Height))
        {
            image.Height = inlineImage.Height;
        }
 
        inlineImage.Child = image;
    }
 
    #endregion
 
  }
}

Documents

moc@zuehlke.com (Christian Moser) — Fri, 03 Sep 2010 15:42:54 +02002010-07-14 16:50:08

Documents

[sublist]

FlowDocuments

moc@zuehlke.com (Christian Moser) — Fri, 03 Sep 2010 15:42:54 +02002010-07-08 17:45:05

How to use FlowDocuments

How to save or load a FlowDocument embedded images

There is a way to save and load a flow document including all embedded images by putting them into a XamlPackage. The following sample shows how to do this:

 
// Save 
var source = new FlowDocument();
var range = new TextRange(source.ContentStart, source.ContentEnd);
using (var stream = File.Create("output.pak"))
{
    range.Save(stream, DataFormats.XamlPackage);
}

 
// Load
using(var stream = File.OpenRead("output.pak"))
{
    var target = new FlowDocument();
    var range = new TextRange(target.ContentStart, target.ContentEnd);
    range.Load(stream, DataFormats.XamlPackage);    
}

How to navigate by hyperlinks

If you have a FlowDocument that contains Hyperlinks and you want to perform some action when the user clicks on the link, you can use hook up to the RoutedEvent Hyperlink.RequestNavigateEvent. The following code snippet shows you how to do it:

 
<Window x:Class="HyperlinksInFlowDocument.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="Window1" Height="300" Width="300">
    <Grid>
        <FlowDocumentReader>
            <FlowDocument>
                <Paragraph>
                    <Hyperlink NavigateUri="http://www.google.ch">Google</Hyperlink>
                </Paragraph>
            </FlowDocument>
        </FlowDocumentReader>
    </Grid>
</Window>

 
public Window1()
{
    InitializeComponent();
    AddHandler(Hyperlink.RequestNavigateEvent, new RoutedEventHandler(OnNavigationRequest));
}
 
public void OnNavigationRequest(object sender, RoutedEventArgs e)
{
    var source = e.OriginalSource as Hyperlink;
    if (source != null) 
        Process.Start(source.NavigateUri.ToString());
}

Images

moc@zuehlke.com (Christian Moser) — Fri, 03 Sep 2010 15:42:54 +02002010-07-08 13:47:32

Images in WPF

How to create a Thumbnail of an Image

 
private ImageSource GetThumbnail( string fileName )
{
   byte[] buffer = File.ReadAllBytes(fileName);
   MemoryStream memoryStream = new MemoryStream(buffer);
 
   BitmapImage bitmap = new BitmapImage();
   bitmap.BeginInit();
   bitmap.DecodePixelWidth = 80;
   bitmap.DecodePixelHeight = 60;
   bitmap.StreamSource = memoryStream;
   bitmap.EndInit();
   bitmap.Freeze();
 
   return bitmap;
}

How to automatically crop an image

The following method allows you to automatically crop an image to it's content.

 
public static ImageSource AutoCropBitmap(BitmapSource source)
{
    if (source == null)
        throw new ArgumentException("source");
 
    if (source.Format != PixelFormats.Bgra32)
        source = new FormatConvertedBitmap(source, 
                            PixelFormats.Bgra32, null, 0);
 
    int width = source.PixelWidth;
    int height = source.PixelHeight;
    int bytesPerPixel = source.Format.BitsPerPixel / 8;
    int stride = width * bytesPerPixel;
 
    var pixelBuffer = new byte[height * stride];
    source.CopyPixels(pixelBuffer, stride, 0);
 
    int cropTop = height, cropBottom = 0, cropLeft = width, cropRight = 0;
 
    for (int y = 0; y < height; y++)
    {
        for (int x = 0; x < width; x++)
        {
            int offset = (y * stride + x * bytesPerPixel);
            byte blue = pixelBuffer[offset];
            byte green = pixelBuffer[offset + 1];
            byte red = pixelBuffer[offset + 2];
            byte alpha = pixelBuffer[offset + 3];
 
            //TODO: Define a threshold when a pixel has a content
            bool hasContent = alpha > 10;
 
            if (hasContent)
            {
                cropLeft = Math.Min(x, cropLeft);
                cropRight = Math.Max(x, cropRight);
                cropTop = Math.Min(y, cropTop);
                cropBottom = Math.Max(y, cropBottom);
            }
        }
    }
 
    return new CroppedBitmap(source, 
             new Int32Rect(cropLeft, cropTop, cropRight - cropLeft, 
                           cropBottom - cropTop));
}

How to flip an image horizontally or vertically

The easiest way to flip an image in WPF is to use a TransformedBitmap. It's a wrapper around a BitmapImage that takes a generic Transform object.

 
var flippedImage = new TransformedBitmap(originalImage, new ScaleTransform( -1,1));

Interoperability

moc@zuehlke.com (Christian Moser) — Fri, 03 Sep 2010 15:42:54 +02002010-07-06 16:40:47

How to get the Handle of a WPF Window

 
IntPtr windowHandle = new WindowInteropHelper(
    Application.Current.MainWindow).Handle;

How to manually set the rendering mode to software

 
var source = PresentationSource.FromVisual(this); 
var hwndTarget = source.CompositionTarget as HwndTarget; 
if (hwndTarget != null) 
{ 
    hwndTarget.RenderMode = RenderMode.SoftwareOnly; 
}

MergedDictionaries

moc@zuehlke.com (Christian Moser) — Fri, 03 Sep 2010 15:42:54 +02002010-07-02 13:29:38

Merged ResourceDictionaries

Problems loading merged resource dictionaries in .NET 4.0

I experienced a problem, when I am trying to merge resource dictionaries at app-level. As soon as I changed the target framework from 3.5 to 4.0 they don't get loaded anymore. It seems as if they have changed something in the behavior of MergedResourceDictionaries in .NET 4.0.

I found a way how to fix this problem. Just add a dummy default style in the resource dictionary where you merge all resources together. See the following example:

 
<Application.Resources>
    <ResourceDictionary>
        <ResourceDictionary.MergedDictionaries>
            <ResourceDictionary Source="Styles/DefaultStyle.xaml"/>
        </ResourceDictionary.MergedDictionaries>
    </ResourceDictionary>
</Application.Resources>

 
<ResourceDictionary 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
 
    <ResourceDictionary.MergedDictionaries>
        <ResourceDictionary Source="DefaultStyle/Button.xaml"/>
    </ResourceDictionary.MergedDictionaries>
 
    <Style TargetType="Control" BasedOn="{StaticResource {x:Type Control}}" />
 
</ResourceDictionary>

Improve the performance of merged ResourceDictionaries

Each time a control references a ResourceDictionary XAML creates a new instance of it. So if you have a custom control library with 30 controls in it and each control references a common dictionary you create 30 identical resource dictionaries!

 
<ResourceDictionary.MergedDictionaries>
   <SharedResourceDictionary Source="/MyControlLibrary;component/Themes/Brushes.xaml"  />
</ResourceDictionary.MergedDictionaries>

To get rid of this problem, I created the SharedResourceDictionary. You can use it the same way as a conventional ResourceDictionary. The only suptile difference is, that if it is instanced multiple times, the resources are loaded only once.

 
 
[assembly: XmlnsDefinition("http://schemas.microsoft.com/winfx/2006/xaml/presentation", 
"WPFTutorial.Utils")]
 
/// <summary>
/// The shared resource dictionary is a specialized resource dictionary
/// that loads it content only once. If a second instance with the same source
/// is created, it only merges the resources from the cache.
/// </summary>
public class SharedResourceDictionary : ResourceDictionary
{
    /// <summary>
    /// Internal cache of loaded dictionaries 
    /// </summary>
    public static Dictionary<Uri, ResourceDictionary> _sharedDictionaries =
        new Dictionary<Uri, ResourceDictionary>();
 
    /// <summary>
    /// Local member of the source uri
    /// </summary>
    private Uri _sourceUri;
 
    /// <summary>
    /// Gets or sets the uniform resource identifier (URI) to load resources from.
    /// </summary>
    public new Uri Source
    {
        get { return _sourceUri; }
        set
        {
            _sourceUri = value;
 
            if (!_sharedDictionaries.ContainsKey(value))
            {
                // If the dictionary is not yet loaded, load it by setting
                // the source of the base class
                base.Source = value;
 
                // add it to the cache
                _sharedDictionaries.Add(value, this);
            }
            else
            {
                // If the dictionary is already loaded, get it from the cache
                MergedDictionaries.Add(_sharedDictionaries[value]);
            }
        }
    }
}