I Got Rhythm

Local values in DependencyObjects

aelij — Wed, 04 Nov 2009 21:38:00 GMT

If you’re writing a custom control in WPF, you may have encountered a very annoying bug: if you set the value of a DependencyProperty in your implementation code, the local value will trump any changes that you may try to apply to this property using bindings, styles, etc. You can read more about this in this post in Vincent Sibal’s blog.

WPF 4 introduces a solution for this problem: the DependencyObject.SetCurrentValue() method. It allows changing the value of a DP without affecting the BaseValueSource. Vincent has a nice post explaining this as well. As he says, a control author should generally use this method instead of SetValue().

However, if you’re still working on a .NET 3-3.5 app, and are encountering this issue, fear not! For there is a workaround, albeit slightly cumbersome. This magic lies within the power of coercion. Like the new SetCurrentValue(), the good old CoreceValue() method does not change the BaseValueSource. So, instead of setting the value directly, put some logic in the coercion callback of your DP. Your bindings and styles will continue to work after that.

I’ve changed the sample from Vincent’s post to use this workaround (take a look at the CustomControl.CoerceTitle() method).

Hey La, Hey La, ClearType’s Back

aelij — Wed, 04 Nov 2009 20:35:20 GMT

One of the most referenced posts in this blog is the one dealing with the ClearType issues. Those of you who shared my pain will be glad to hear that Microsoft has delivered on its promise: WPF is getting a new text rendering stack in v4, which has the ability to render ClearType (and even aliased text) in every scenario. The new stack is also supposed to match the GDI text renderer, which means that small text will be much more readable.

You can download Visual Studio 2010 Beta 2 and give it a try. I’m sure you’ll be pleased with the result.

For more information, head on to this post at the WPF Text blog.

As a side note, I’ve started working as a Senior .NET Consultant for Sela Group. Hopefully you’ll be seeing a lot more posts this year.

Presenting PresentationHost

aelij — Mon, 09 Feb 2009 14:26:00 GMT

I always prefer simpler solutions. The solution I proposed on my previous post was not that simple, and was not complete. It may still be useful for other stuff, but for the purpose of preserving ClearType while using DWM, I just have to admit it has too many issues.

The idea of using another window stayed in my head, and then I realized I could use a child window. WPF already has a mechanism for hosting Windows Forms and ActiveX controls. They derive from HwndHost,which allows creating a window handle and embedding it within the WPF visual tree.

My control, PresentationHost, does just that. It hosts an HwndSource, which provides the infrastructure of WPF windows. You give the HwndSource a root visual to display, and since it is a separate window within the main window, whose composition background remains opaque, ClearType works just fine. You don’t have to modify anything in the Ribbon. Even routed commands work transparently!

The one downside I can think of is that everything inside the host is not part of the visual tree of the window. I did make sure it’s a part of the logical tree, so there’s a way to get into elements inside the host. XAML name references also work as usual.

Again, to compile/run the sample, you’ll have to obtain the Ribbon assembly separately from the Office UI Licensing site.

Casper to the Rescue!

aelij — Fri, 06 Feb 2009 14:39:00 GMT

WPF has ClearType issues. Hopefully some of them will be solved in the upcoming .NET 4.0. Meanwhile, however, I have concocted a nifty solution to one of the scenarios – placing stuff on the Aero Glass DWM frame.

When you extend the DWM frame in a WPF application you must set the HwndTarget.BackgroundColor property to Transparent, which turns off ClearType for the entire window.

Most of the Ribbon implementations do this so they could place the application menu (the round button) halfway on the window title, as well as the quick access toolbar. Since Ribbon-based applications are mostly document-oriented, this is particularly bad, since it completely botches the text readability of the app.

I had an idea how to solve this a while ago, and just didn’t have the time to code it. Now I’m working on a project that actually uses a Ribbon, and I wanted my app to be readable even on Vista (and 7 ;), while retaining the nice glassy look.

Introducing GhostContentPresenter

The Ghost Content Presenter is a custom control which displays arbitrary WPF content, with a special twist: the content is positioned as if it’s part of the visual tree where the GCP is added, but in actuality it is rendered in a Popup, whose position and size are kept synchronized with the parent Window.

I needed to make a couple of changes to the Popup: make it non-top-most and make the Window that contains the GCP its owner. This way, the Popup will always be above the Window, but never above other windows.

Now, all I had to do is retemplate the Ribbon control (I used the Microsoft CTP) to use GhostContentPresenters (MS should really provide the XAML for the Ribbon).

There are still a few issues left to sort out: (1) Writing the title text (it needs to be offset according to the quick access toolbar, whose width is dynamic, and I didn’t want to use another GCP just for it, though it’s possible). (2) The Popups appear a split of a second before the Window when restoring a minimized window because of the DWM effect. (3) Binding to commands cannot be done the same way, since routed commands (which use routed events), bubble up the visual tree, and the Popup is not part of it. One solution would be to hook the commands statically using CommandManager.RegisterClassCommandBinding().

Let me know if you think of other original uses for the GCP (remember the popup can even appear beyond the window borders!) It will be included in the next version of WPF Contrib.

PS – I’m sorry I can’t include a working demo this time. You’ll have to obtain the Ribbon assembly separately from the Office UI Licensing site.

Update: I’ve added a timer to deal with the DWM effect delays (controlled by the IsDelayEnabled property). It’s a hack, but it works. Also, I’ve added an IsGhosting property, that when set to false causes the GCP to behave like a regular ContentPresenter.

Normality Restored

aelij — Tue, 27 Jan 2009 10:05:00 GMT

The past 24 hours have been a blogger’s nightmare for me. I wanted to upgrade my GoDaddy’s hosting account to IIS 7. Unfortunately, they do not have any upgrade option, so you have to call their customer service, cancel your current hosting account, create a new one and build everything from scratch.

What this means, of course, is that you have to backup your current website yourself. I created a backup of the SQL database, and used FileZilla to transfer all the files to my computer. Now, here’s where my stupidity comes in: When FileZilla finished the transfer I assumed all was OK. I quickly browsed the root directory and saw that all the sub directories were there, but I forgot to verify the most important thing: the database backup. It seems the wretched FTP software reports errors into a tab at the bottom, that doesn’t even get focus if there were any. Talk about trustful computing.

I realized my grave mistake only after the old account was gone, when I went to upload the website to its new location. I immediately called GoDaddy. It was a matter of minutes since the account was cancelled, yet they informed me that the restore fee would be $150! That’s how much it costs me to host the entire site for two years! I told them I’d get back to them.

What could I do? Well, it was Google who came to the rescue. Google indexes my blog. Google has cache! So I wrote a small program which fetched the cached pages (per post, since I wanted to restore the comments as well) and parsed them into a simple data structure, which I serialized into an XML file. That was the easy part. The hard part was using the cumbersome Community Server API to repost everything.

As a side note, GoDaddy does have one useful tool, which I only found later (and which might have saved me all this trouble): You can compress/uncompress files using their file manager. Had I compressed the entire site with the DB backups into a single file, I never would’ve missed anything. And the transfer is much faster that way.

It’s finally over and normality has been restored. The old posts’ unique IDs may have changed because of this debacle, so I’m deeply sorry if some of them have been duplicated in your RSS reader. I have attached the code I used, should anyone ever need it (it’s a bit messier than my usual standards). I also added the two config files you need in order to setup Community Server 2008.5 as a single user blog (spent a few hours digging that one up).

Morals of the story:

Never trust an FTP software for backup. Verify it again and again.
TANSTAAFL. GoDaddy is cheap, but I just discovered a major disadvantage.
You should backup your website regularly on your own. Don’t rely only on your hosting provider.
Being the good Atheist that I am, I have accepted Google as my personal savior.
URLs are important. I worked extra hard so that all of the old URLs would remain the same.

Theme Manager: A Hackly Hack

aelij — Sun, 28 Dec 2008 19:47:00 GMT

One of the most popular posts in this blog is the one explaining how to override the system theme and get the Vista look on non-Vista systems. This is possible because WPF ships with the theme files for all operation systems (well, all Microsoft OSs that WPF works on, i.e. XP, XP Media Center and Vista) and due to the fact that WPF doesn’t really use the system resources to get the OS theme, but rather relies on a private implementation of them that resides in the PresentationFramework.{Classic, Luna, Royale, Aero} assemblies.

The solution offered in the aforementioned post loads a selected theme dictionary from one of these assemblies to the Application resource dictionary. While this is enough to modify the theme for all the built-in controls, you may encounter problems in the following scenarios:

You’re using third-party controls that have their own themes for each of the system themes. Many of these controls have a method of bypassing the system theme. (For example, see the Theme property on the Xceed DataGrid.)
You’re writing a theme for your own control. Resources in the Themes folder do not go through the same lookup chain as other resources, so when you’re using built-in controls there, their theme may not be affected by the Application resource dictionary.

As an experiment , I’ve decided to hack into the bowels of WPF and force it to recognize a different theme as the system theme. I must say this is one of the ugliest hacks I’ve ever done. The result is the class ThemeManager, which exposes a single static method:

public static void ChangeTheme(string themeName, string themeColor);

Examples of theme name and color pairs: { “luna”, “homestead” }, { “royale”, “normalcolor” }, { “classic”, “” }. If you pass two empty strings, the default system theme will return. You can also invent a new theme of your own, give it a name and load it this way. I haven’t tried it, but it should work, as long as you conform to the theme dictionary location conventions.

I also hooked into the message loop and am intercepting the theme change message that is sent to all windows. This blocks WPF from attempting to apply a new theme when the system theme changes.

Needless to say I’m using tons of reflection and it’s likely to break in the next version, so don’t use it. I think this should have been part of the API to begin with.

PS – A helpful tip for the theme author: you can find the sources (XAML) for all the themes in the Windows SDK samples (look in WPFSamples.zip/Core/{Classic, Luna, Royale, Aero}Theme.)

Update: Apparently this still works in .NET 4 (as of Beta 2).

New Release of WPF Contrib

aelij — Wed, 05 Nov 2008 20:02:00 GMT

I've released a new version of WPF Contrib (October 2008, although it's released in November. I changed the release name a few times, so I decided to leave it like that. I'm only late by a few days. :)

It contains quite a few fixes and new features. Read about it in the project wiki. There are some breaking changes, which, unlike Microsoft, I can easily make, since I don't really have a huge user base. Although, many of the new features in TaskDialog were motivated by user requests. Many of the new controls and classes already appeared in articles in this blog.

I've also set up an XBAP demo (only for features that work in partial trust):

http://arbel.net/wpfcontrib/AvalonLibraryTestBrowser.xbap

As always, I would like to hear from you if you have suggestions and bugs.

Activator 2: XAML and Generics Day

aelij — Mon, 27 Oct 2008 09:38:00 GMT

First of all, you didn't miss part one. Just thought it was a funny reference.

I'm currently working on a new release of WPF Contrib. In my TaskDialog class, I used a few classes I derived from ItemsControl (which I'm considering deleting in this version, but that's another debate). The reason I created them was so that you could add any item to the ItemsControl and it would be wrapped in some specific ContentControl, such as a Button. But if you added a Button, it would know that it doesn't need wrapping (this is what the IsItemItsOwnContainerOverride() and GetContainerForItemOverride() methods do).

I had three classes which were exactly the same, aside from the type of the ContentControl. Generics would very much fit here, but unfortunately, XAML has a very limited support for it (it seems the new .NET 4.0 XAML stack will improve this, and much more). As an exercise I decided to try and extend XAML so it will support generics - on a basic level.

XAML can be extended using MarkupExtensions. These are classes that have a single method, ProvideValue(), that when XAML (or BAML) is loaded, create objects according to some custom logic. You're surely familiar with the TypeExtension (x:Type), which returns a System.Type from the specified qualified string. What I've done is create two new extensions:

An alternative TypeExtension that supports type arguments. The following is equivalent to typeof(List<List<KeyValuePair<string, int>>>):

{t:Type gen:List, {t:Type gen:List, {t:Type gen:KeyValuePair, sys:String, sys:Int32}}}

Note that you don't have to (but can) specify gen:List`1. The number of type arguments will be inferred. The constructors support up to 4 type arguments. In the unlikely case that you need more than that, you can use the unabbreviated form and specify the arguments as sub-elements.

An ActivatorExtension that accepts a type (either generic or not) and a list of property-value pairs. For example, this will create an instance of ItemsControl<CheckBox> (a generic variation of ItemsControl I have in the demo), and assign some of its properties, including a binding:

<t:ActivatorExtension x:Name="ic" Type="{t:Type t:ItemsControl, {t:Type CheckBox}}">
    <t:Setter Name="Name" Value="ic" />
    <t:Setter Name="Background" Value="{Binding ElementName=tb, Path=Text}" />
    <t:Setter Name="ItemsSource">
        <x:ArrayExtension Type="{x:Type sys:String}">
            <sys:String>one</sys:String>
            <sys:String>two</sys:String>
            <sys:String>three</sys:String>
            <sys:String>four</sys:String>
        </x:ArrayExtension>
    </t:Setter>
</t:ActivatorExtension>

There are, however, a few severe limitations:

The Name property has no effect, either on the extension or as a property. Not only does the XAML compiler not generate a member for it in the partial class, but the FrameworkElement.FindName() method also doesn't work. In templates, however, FindName() will return the extension itself, not the constructed object (if you add the x:Name attribute to it). This can be a big problem if you want to use an activated object as a template part.
Special treatment has been given for bindings to work in property values. Other expressions, such as DynamicResource or TemplateBinding, will not.
XamlWriter.Save() fails to save an object that contains an activator with a generic type (which makes sense since XAML does not support generics, and after it's loaded, the MarkupExtension is gone.)
The ActivatorExtension cannot be used as the root of a template (fails at compile time). This can be easily circumvented though, by surrounding it with a Decorator.

As I said in the beginning, this was just an experiment I wanted to share, and in no way should be viewed as a production-quality solution. I will, however, be adding the TypeExtension to the upcoming drop of WPF Contrib. It can be used to specify DataTemplate resource keys for generic types.

License

aelij — Sun, 26 Oct 2008 15:54:00 GMT

I've added a license page to my blog.

As indicated there, all code (unless noted otherwise) is released under the MIT license.

Improper use of InteropBitmap can cause a memory leak

aelij — Wed, 22 Oct 2008 10:29:00 GMT

I've been using InteropBitmap in my GdiTextBlock. The control creates a new GDI+ Bitmap every measure pass, which it then converts to a WPF BitmapSource using the Imaging.CreateBitmapSourceFromHBitmap() method (this method returns an InteropBitmap).

After playing with the control for a while I noticed that the process' working set is constantly increasing. I realized I must have a problem with my bitmap conversion. So, I set out to seek an alternative solution, and I came up with a simple way of creating a BitmapSource directly from a GDI+ Bitmap. (See attached. I've also updated the GdiTextBlock post.)

After some more digging, I found out that the leakage was entirely my fault. To use the CreateBitmapSourceFromHBitmap() method, you have to convert the GDI+ bitmap to an HBITMAP by calling the Bitmap.GetHbitmap() method. Its documentation clearly states that "You are responsible for calling the GDI DeleteObject method to free the memory used by the GDI bitmap object." Well, there you have it.

I decided to benchmark the two options. Here are the results:

Interop Bitmap No Delete
------------------------
Time: 00:00:01.5989544, Process Memory: 396,936 KB

Interop Bitmap With Delete
--------------------------
Time: 00:00:01.5158545, Process Memory: 9,056 KB

Alternate
---------
Time: 00:00:00.5108011, Process Memory: 9,080 KB

It would seem that the alternate method is preferable even after deleting the HBITMAP. I think the reason for the (time) overhead is that the GDI+ bitmap needs to be converted to an HBITMAP, and then converted to a WPF bitmap, while in the alternate method, we skip the middleman.

Side note: I'm using a new .NET 3.5 SP1 feature, which allows forcing a garbage collection using the GC.Collect() method (which has a few new overloads as well). Can be pretty useful for benchmarking or debugging.

Shady Pixels

aelij — Sun, 19 Oct 2008 18:06:00 GMT

In my previous post I mentioned the new Zune 3.0 visualizations. I really liked them, so I decided to try and create them using WPF's new (3.5 SP1) Effects.

A while ago I wrote about BitmapEffects, and why you should try to avoid them. Effects replace BitmapEffect with an elegant, hardware-accelerated API. An Effect is comprised of a class that derives from ShaderEffect and another file written in HLSL (High Level Shader Language), which is a C derivative. What you're basically writing is a function that receives the coordinates of a pixel and returns a color - a pixel shader. If you want to learn how to write one, I suggest checking out Greg Schechter's series. You should also have a look at the WPF Effects Library, which has a host of ready to use effects, and also shows a great way of using effects to create transitions.

Now, for my Zune mimic. I created two effects: Blend (which blends one element with another) and PointLight (which colorizes an element and adds two light orbs). I also added a few animations to the demo app, which made it look more like Zune. The result is quite pleasant.

Although I'm quite satisfied with the API, there are a few things that aren't so good:

Debugging effects is not trivial.
Using multi-input effects on a few UIElements is cumbersome. You have to use a VisualBrush. There should be a way to apply an effect like Blend by specifying the two (or more) elements it's supposed to work on.
You cannot apply an effect to the background of a Visual. What I mean is that creating an effect like Glass in Vista is impossible. If I apply a BlurEffect on a semi-transparent surface, only the contents of that surface will be blurred, and not what's visible through it.

To compile the attached project, you will need the Shader Build Task and Templates, available at codeplex.com/wpf (WPF Futures release).

In the Zune

aelij — Wed, 17 Sep 2008 12:06:00 GMT

I'm loving the new Zune 3.0 client software. V1 was terrible. Just an ugly version of Windows Media Player. V2 was completely rewritten using a Microsoft internal platform called UIX, which is based on Media Center. Although it's still .NET, I was slightly disappointed they didn't use WPF.

Anyhow, it's still a great piece of software, very fluent and intuitive, and it looks cool with all sorts of smooth animations. In V3 they added a few nifty features, such as new Now Playing visualizations. It downloads photos and data (such as number of plays) from the web, and performs a very attractive pan, zoom and tint effect on them. Here are a few shots:

In addition, there's the Mix View, which allows you to effectively view related albums and artists. You can play, buy or get more info directly from this view:

I've had my Zune (30GB) for over a year now, and it has gone through a lot. It's quite battered. A month ago, it fell on the pavement and suffered a nearly-lethal blow. What really blows is that the device is fully functional, but the display is cracked, with a large black stain in the middle:

So now I'm considering buying the new (flash memory-based) 16GB Zune. The new 3.0 firmware also has a few new features I like: browse the marketplace wirelessly and games. What I'm still missing is support for international fonts (mainly Hebrew) and search (the marketplace has it - with a great interface.)

Good Old GDI+ (or: Unblur Thy Text)

aelij — Mon, 18 Aug 2008 10:35:00 GMT

It's been a while since I've done anything with GDI+ (i.e. System.Drawing). System.Windows (i.e. WPF) is so much more powerful.

However, there's one area where it seems the good old GDI+ can still surpass it's shiny new successor: text.

There have been many complaints about text rendering in WPF. I wrote about some of them myself. You can find a lot of questions on the WPF forum (to name a few), but not a lot of answers.

The main issue is that small text is blurry and unreadable. When asked how to render aliased text in WPF, the answer was: it's impossible. However, I recently encountered a whitepaper on windowsclient.net called "Text Clarity in WPF", which suggests a way to do just that. It's worth a read, even though the aliased text solution provided there is not usable (they use FormattedText, convert it to a Geometry and render the Geometry aliased using RenderOptions.SetEdgeMode() - which indeed renders aliased text, but it's not quite legible.)

As you may have already guessed, my solution - GdiTextBlock - relies on GDI+. We render a bitmap that contains the text and display it. As you may know, rendering bitmaps in WPF also has it's problems, which is why I use the Bitmap control in order to prevent bitmaps from becoming blurry as well.

Also, in order to maintain compatibility with WPF's TextBlock, and to avoid forcing the consumers of the control to add a reference to the System.Drawing assembly, the properties and their types are all the same as TextBlock's (in fact, the dependency properties are registered using DependencyProperty.AddOwner(), which also ensures that value inheritance down the visual tree works.) CoerceValueCallback is used in many places since GDI+ doesn't support all the options available in WPF (e.g. FontStyles.Oblique, non-solid Foreground, TextAlignment.Justify.) While I've included a property called TextQuality, which allows you to set the TextRenderingHint, you'll see that only the default (SingleBitPerPixelGridFit) provides legible results.

One last note about performance - this solution is not quite optimal. It creates a bitmap every measure pass. I haven't done any real performance tests, so I can't tell you what the real penalty is. Use it at your own discretion.

Update: Fixed a small bug and added size and color selectors to demo app.

Another Update: Fixed a leak when using InteropBitmap. See this post.

Writing Methods and Classes in LINQPad

aelij — Mon, 18 Aug 2008 08:54:00 GMT

LINQPad is a very useful code snippet IDE. I use it all the time to test small pieces of code. It's much more convenient than opening a new Visual Studio console application. It also formats the results very nicely.

What seems to be missing in LINQPad is a way to add methods or classes. After digging a bit with reflector, I came up with a simple way:

Choose "C# Statement(s)" in the Type drop-down.
Write the code that LINQPad should execute.
Put a closing curly-bracket ("}") at the end.
Write as many classes and methods as you like.
On the last class/method, omit closing curly-bracket.

LINQPad simply compiles the code you're writing there, wrapping it in a class and a single method, which it then executes. By adding the closing bracket, we're actually ending the method it defines, and start writing our own methods and classes. Since a closing bracket will be added at the end of the code block, we omit it from our code.

If you want your classes to be proper (not inner), you will need to put two closing curly-brackets, and then define your class. This is important if you want to define extension methods (which must reside in a static, non-inner class).

C# Partial Specialization With Extension Methods

aelij — Thu, 22 Nov 2007 06:46:00 GMT

One of the things C# generics lacks (compared to C++ templates) is specialization (neither explicit nor partial). This can be very useful in some cases where you want to perform something differently for a specific T in a Class<T>.

With C# 3.0, there is a relatively easy way to achieve this, albeit not optimal, for reasons I'll specify later on. Take a look at the following piece of code:

public class SomeClass<T>

{

private readonly List<T> items = new List<T>();

internal void AddInternal(T item)

{

items.Add(item);

}

[EditorBrowsable(EditorBrowsableState.Never)]

public static class SomeClassExtensions

{

public static void Add<T>(this SomeClass<T> c, T item)

{

c.AddInternal(item);

}

public static void Add(this SomeClass<int> c, int item)

{

if (item <= 0)

{

throw new ArgumentOutOfRangeException("item", "Value must be a positive integer.");

}

c.AddInternal(item);

}

Instead of placing the Add method in SomeClass<T>, we put it in a static class that has extension methods. This allows the compiler to select the appropriate method according to the type parameter. (Side note: I've specified the EditorBrowsable attribute so that the class with the extensions would not appear in VS intellisense.)

The biggest caveat about this is that extension methods do no have access to private members, so the only option is to make the members internal, which, in many cases, leads to a bad design. If only extension method classes could be written as inner classes...

Also, extension methods, being static, could not be virtualized. You can, however, make the internal method "protected internal virtual".