<r:Ribbon cal:RegionManager.RegionName="ApplicationRibbon"> ....</r:Ribbon>

you will get a KeyNotFoundException.
Diving a little bit deeper shows you that the RegionManager cannot find a RegionAdapter mapping for Microsoft.Windows.Controls.Ribbon.Ribbon.That means that we have to write a RegionAdapter for the Ribbon Control.Implementing IRegionAdapter should suffice but as we are lazy, we could just inherit from RegionAdapterBase<T> (where our T will be Ribbon) and we will end up with something short like this:

 public class RibbonRegionAdapter : RegionAdapterBase<Ribbon>
    {
        protected override void Adapt(IRegion region, Ribbon regionTarget)
        {
            region.Views.CollectionChanged += delegate {
                foreach (var tab in region.Views.Cast<RibbonTab>())
                {
                    if (!regionTarget.Tabs.Contains(tab))
                    {
                        regionTarget.Tabs.Add(tab);
                    }
                }
            };
        }

        protected override IRegion CreateRegion()
        {
            return new SingleActiveRegion();
        }
    }

at least we have to Register this RegionAdapter in our bootstrapper. Therefore we just override the Bootstrapper’s ConfigureRegionAdapterMapping’s method:

protected override RegionAdapterMappings ConfigureRegionAdapterMappings()
        {
            var mappings = Container.TryResolve<RegionAdapterMappings>();
            if (mappings != null)
            {
                mappings.RegisterMapping(typeof(Ribbon), new RibbonRegionAdapter());
            }
            return mappings;
        }

Now we should be able to add RibbonTab’s to the ribbon from within our Modules using RegionManager (we can easily resolve this from our IoC Container).

This is no full featured quality guide for using the Wpf Ribbon control with CompositeWpf. It just shows that writing custom region adapters is actually quite an easy thing.

The Webbrowser control is just a native Win32 Hwnd that gets hosted inside some WPF content area. But it’s quite annoying that the Transparency stuff gets pass on to it.
I wonder how i could circumvent this limitation as i don’t need transparency in the webbrowser control itself. Its just to get some homegrown, fancy-looking window style.

I’m looking forward to see this fixed by Microsoft in some future release.

Disclaimer:This is not a ready to use fully-featured control for production use. It just shows in a very simple manner how to get Properties and their values from objects via reflection and show them using WPF and databinding.
It is by far not a replacement of commercial WPF PropertyGrids (e.g. MindScape WPF PropertyGrid), more a fast solution for minimal requirements.

This simple PropertyGrid will not contain special Editors for non trivial data types. For now we are confident with a simple TextBox for demonstration purposes.
We will see that because of the automatic conversion features of wpf , we’re easily able to edit not only strings, but also int’s, double’s, Color’s, SolidColorBrush’es and so on in a simple TextBox.

Our WPF PropertyGrid clone should look like this:

• TextBox for searching (filtering) properties. This is especially usefule if your classes contain lots of properties
• a panel (here StackPanel) that contains all the PropertyName/PropertyValue pairs (wrapped up in a Scrollviewer)
• TextBox for descriptions that we obtain from the System.ComponentModel.DescriptionAttribute-Attribute of the property selected

First we want to realize the simple structure shown above in XAML to get started.
After short time this may look like this:

foreach (PropertyDescriptor property in TypeDescriptor.GetProperties(value)){

	if (!property.IsBrowsable) continue; //not browsable. ignore

        PropertyItem currentProperty = new PropertyItem();
        currentProperty.PropertyName = property.Name;
        Binding b = new Binding(property.Name);
        b.Source = selectedObject;
	//OneWay Binding if readonly, twoway else
        b.Mode = property.IsReadOnly ? BindingMode.OneWay : BindingMode.TwoWay;

        currentProperty.SetBinding(PropertyItem.PropertyValueProperty, b);
	currentProperty.OnActive += new EventHandler(currentProperty_OnActive);

        foreach (Attribute attribute in property.Attributes)	//check attributes
        {
         if (attribute.GetType() == typeof(DescriptionAttribute)){ //description to show in description textbox
            currentProperty.PropertyDescription = ((DescriptionAttribute)attribute).Description;
         }
         if (attribute.GetType() == typeof(CategoryAttribute)) {  //categories known from winforms pg.not implemented
             currentProperty.PropertyCategory = ((CategoryAttribute)attribute).Category;
         }
        }      

	PropertyPanel.Children.Add(currentProperty); //add PropertyItem to panel
}

That’s it! Well, what happened here?
We iterate over all properties the object, we set as SelectedObject, contains. If it’s marked as non-Browsable (System.ComponentModel.BrowsableAttribute), we’ll just skip it, otherwise we create a PropertyItem, set its name and create a Binding to connect the PropertyItem’s PropertyValue-property with the value of the actual property from SelectedObject.

And before we add the PropertyItem to our Panel, we check the attributes of the source property (e.g. to get the description from the DescriptionAttribute or the get the corresponding category from the CategoryAttribute, which is not processed for simplicity in this demo).

When we now try to set some object to our PropertyGrid’s SelectedObject-property (in this case a dummy class containing several properties, including string, int, double, color, SolidColorBrush and a property marked with Browsable(false)) it should look like this:

In the screeshot above you can see different data types in their string representation. You don’t have to care about converting them back manually to their actual type as WPF’s Binding-Helpers do everything for you (and will throw Exceptions if the string-format for your type is wrong).

At last we add some Style to our PropertyGrid and received something like this:

…and add the PropertyGrid itself somewhere in your XAML code

at last you have to provide some object (that contains some properties) to the SelectedObject property:

//...
this.propertyGrid.SelectedObject = myCustomObject;
//...

You can download the whole solution here: PropertyGridDemo.zip

But what if you want to display some Properties of your objects in another format (i.e. something other that ToString() returns) ? You can either override ToString() or try to use another (imho more elegant) way.
Therefore WPF offers an Interface called IValueConverter

public interface IValueConverter {
   public object Convert(object value, Type targetType, object parameter, CultureInfo culture);
   public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture);
}

When implementing this interface in your own class, you can probably do everything you can imagine with the values you try to format. You can e.g. display the birthdate instead of its (normal) DateTime representation as Base64-string (this has no real use, it’s just an example of how far you can go). Therefore we create the following converter:

public class Base64Converter : IValueConverter
{
  #region IValueConverter Members

  public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
  {
      return System.Convert.ToBase64String(Encoding.ASCII.GetBytes(value.ToString()));
  }

  public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
  {
      return Encoding.ASCII.GetString(System.Convert.FromBase64String(value.ToString()));
  }

  #endregion
}

Next we have to add our Namespace to the Window:

<Window x:Class="CustomValueConverter:Window1"
. . .
xmlns:converters="clr-namespace:CustomValueConverter.Converter">

In the next step we create our Converter in our Window’s Resources:

. . .
<Window.Resources>
    <converter:Base64Converter x:Key="base64"/>
</Window.Resources>
. . .

And from now on we can use our Converter everywhere we use DataBinding. For example:

. . .
<TextBlock Text="{Binding Path=Birthday,Converter={StaticResource base64}}"/>
. . .

would give the following result:

You can also pass parameters directly from XAML to a class implementing IValueConverter. This could be useful if you want to e.g. display some DateTime values in your own format.
Therefore we change our Convert()-method in the following way:

public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
     return ((DateTime)value).ToString((string)parameter);
}

Now the DateTime value will be formatted corresponding to our format string we supply as a parameter from XAML. We can declare our parameters like this :

<TextBlock Text="{Binding Path=Birthday,
                  Converter={StaticResource parameterized},
                  ConverterParameter='dd@MM@yyyy'}"/>

what gives us the following result

With ValueConverters you can transform your objects to any representation you want. You’re only limited by your imagination.
The ConvertBack() method of IValueConverter is needed to convert the values from Convert() back to its original representation.
This is necessary especially if you bind some values to TextBoxes (or other value-changing controls) and don’t want your user to use the original representation of your object’s values.

I know that VMWare Fusion didn’t support Aero in their first version, but as Vista works perfectly in my VM (with DirectX support enabled) i didn’t thought of this being an issue.

When i turned off DirectX support for my Virtual Machines, WPF worked as expected….Ticket closed.

Update: This post was originally targeted at VMWare Fusion 1.1. I recently tested their 2.0 release and it seems that VMWare has fixed some the problems when displaying WPF Applications. However, (at least on XP SP2) when using normal wpf applications (no excessive 3D stuff) it feels somewhat slower and has more delays compared to software-only rendering in Vmware fusion 1.1. And some of my applications just show empty windows when 3D acceleration is turned off. Conclusion: VMWare Fusion is still a mess for WPF developers.

The only solution that works for me so far is disabling hardware rendering for all WPF apps (as it is slow when 3d support is enabled and NOT USABLE when 3d support is disabled withing vmware fusion.).
To disable hardware rendering create (or modify) the following registry Dword:

HKEY_CURRENT_USER\SOFTWARE\Microsoft\Avalon.Graphics\DisableHWAcceleration

and set it to 1 to disable.

starten und gut.