I Got Rhythm

In the Zune

aelij — Wed, 17 Sep 2008 14:06:50 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 12: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.

Writing Methods and Classes in LINQPad

aelij — Mon, 18 Aug 2008 10:54:12 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 08: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".

Vista Fish

aelij — Sun, 16 Sep 2007 12:40:46 GMT

About a month ago I went on a trip to London. I just got to uploading the photo album.

One of the places we visited there was the London Aquarium. I took a photo of some glass catfish, which reminded me of Windows Vista:

The WPF Contrib Project

aelij — Tue, 04 Sep 2007 00:26:29 GMT

I've been quiet for a while. Working a lot, and also burning the midnight oil, trying to bring life into this project I call... the WPF Contrib.

Set up at CodePlex, WPF Contrib is mainly a library of reusable components. My goal is for it to become a true community project. Meanwhile, I invite everyone to review the code, play with the demos and send me feedback! If you want to join, the doors are open. You only need to be a WPF expert :P and have motivation to innovate and share.

I'd also love to hear about what you would like to see in this library. You can use the CodePlex Issue Tracker to request features (or just email me).

The latest addition to the library (and one of my favorites) is the TaskDialog control. I've been wanting to write it for some time now. Using it, you can create Task Dialogs in every WPF-supported platform. They help make a very good UX.

Ælij.

Yet Another Upgrade

aelij — Fri, 29 Jun 2007 14:18:00 GMT

I've upgraded to Community Server 2007. Unfortunately, the entire theme model is changed, though for the better, I don't have the time to update my Aero theme, so I chose Kid Congo right now. The main reason for upgrading is the built-in FeedBurner support. It's an excellent service that gives you a bit more information about your readers.

I love getting responses, so don't be afraid to drop me a line if you got the time. :-) BTW, it seems there was some problem with the mail settings on the server, so if you did try the contact form and never got a reply, I'm sorry. You can also reach me at aelija via gmail.

New York, New York!

aelij — Wed, 06 Jun 2007 20:53:00 GMT

I've recently visited New York City for the first time. I had an awesome trip; strolling around in the streets, visiting museums and checking out the gay scene. I did not get to see Lady Liberty, because as it turned out, you have to pre-register to get inside her.

I took a few photos. The worst thing about traveling alone is that you're dependent on strangers' graces to get yourself photographed. :) But it wasn't that bad, and people have been very nice. I uploaded the entire album:

http://picasaweb.google.com/aelija/NewYorkCity/

The trip was my "between-jobs-vacation". I don't think I ever mentioned it on the blog, but I used to work for Amdocs. After almost three good years, I've decided a change pace was in order, and so I moved to a startup company named Varonis.

Lastly, I know I don't normally write about personal stuff on the blog. That's mostly because I don't have anything interesting to report, and also because this blog has a more technological nature. I'll consider opening a second blog, should the situation merit it. The inspiration for this came from Kevin Moore, when I recently saw his "2006 Year in Review". He sure got a lot done that year. :-) Kevin is a program manager on the WPF team (and if you're a WPF developer you should subscribe to his work blog.) For the time being I'll just add the tag "personal" to posts of this nature.

Trace (route) that call!

aelij — Sun, 06 May 2007 21:50:00 GMT

Have you ever used EventManager.RegisterClassHandler()? If so, make sure you know what you're doing. This method allows you to listen to events passing through (as I like to put it) an element (i.e. bubbling or tunneling), regardless of the class that invoked the call. Most of the times you would call it in a static constructor, and pass it a typeof of that class, but that is only a recommendation. The documentation is a bit weak on this point.

This can be a very powerful tool if you use it right. Let me demonstrate. Say you want to listen to all button clicks in your app. Normally you would put this in your main Window (by calling the above method or UIElement.AddHandler() instance method) so all the ButtonBase.Click event would bubble up to the Window and get caught.

But what you can actually do is call the RegisterClassHandler from anywhere you like (it doesn't have to be a static constructor or even a DependencyObject. But remember that every call would add a handler, so beware of multiple registrations!):

EventManager.RegisterClassHandler(typeof(ButtonBase), ButtonBase.ClickEvent, new RoutedEventHandler(SomeMethod), true);

This method has no idea from where it's called, nor does it care. All that matters is that the bubbling or tunneling passes through an element of the type you specified.

Since the Click event would always pass through a ButtonBase (well, actually originate from one. That is, unless you invoke it from some custom class, which doesn't make too much sense most of the time. But I'm going off on a tangent here.) the method would be invoke for every button click. The last parameter makes sure it's invoked even if you marked the event as handled somewhere along the way (albeit redundant in this case, since we handle it right at the root of the bubble.)

[This post was brought to you by Marjorie Dawes. Dust, anybody, no? :-]

i'm (making a difference)

aelij — Thu, 22 Mar 2007 22:38:00 GMT

Microsoft has started a new program to donate some of Messenger's ad revenue to various organizations dedicated to social causes. Join by clicking the banner on the left. You don't have to do a lot to make a difference. :-)

(I chose UNICEF.)

Dispatch It

aelij — Fri, 16 Feb 2007 13:57:00 GMT

In WPF, like most UI frameworks, UI elements can only be updated from the thread they were created on. If you do background work, and want to affect the UI from a different thread, you'll have to dispatch it. The Dispatcher class has a CheckAccess() method (which is marked as EditorBrowsableState.Never, making it invisible to intellisense for some reason.)

Here's how you would normally use it:

delegate void CallMeDelegate(Button b);

void CallMe(Button b)
{
    if (!Dispatcher.CheckAccess())
    {
        Dispatcher.Invoke(DispatcherPriority.Normal, new CallMeDelegate(CallMe), b);
        return;
    }

    b.Foreground = Brushes.Red;
}

You have to create a delegate, check for access and dispach if necessary. However, there's a smarter way, if you allow for a bit of Reflection:

void CallMe(Button b)
{
    if (UIHelper.EnsureAccess(MethodBase.GetCurrentMethod(), this, b))
    {
        b.Foreground = Brushes.Red;
    }
}

What MethodBase.GetCurrentMethod() does is actually give you a method descriptor of the calling method (quite useful for a few scenarios! Too bad they don't have a GetCallerMethod() as well...) The EnsureAccess() method then checks with the dispatcher if we're on the right thread, and if not, dynamically dispatches it.

Last note: Dispatchers run a prioritized queue, so it can be handy to set the DispatcherPriority to something other than Normal. For example, if you set a Dependency Property's value, and want to do something after the UI was updated, try dispatching it with ContextIdle priority.

For more information about Dispatchers, you should read Nick Kramer's whitepaper.

Update: I also discovered the existence of the DispatcherSynchronizationContext, which inherits from the good old SynchronizationContext of .NET 2.0. The original one uses ThreadPool to queue items, while the WPF one uses the Dispatcher mechanism, which is more suitable for WPF. Note that this way you cannot specify a priority. I still believe the way I described above is slightly better.

Another Update: I've changed a few things in the implementation. Now it checks whether the object it receives is a DispatcherObject, and if so, uses its Dispatcher instead of the Application's. This is good for (the rare) cases where your UI itself runs in more than one thread.

BitmapEffect Begone

aelij — Fri, 09 Feb 2007 14:30:00 GMT

You can do really neat things with Bitmap Effects in WPF. Shadow, Bevel, Outer Glow can all have a great impact on how your application looks. But you should be aware that they don't come cheap. They are rendered in software, which yields very poor performance. Also, ClearType is turned off on elements that have them applied, so your text becomes blurry.

So, what to do?

Abstinence. Now, I'm not really a prude, but in this case, minimizing the use of bitmap effects can significantly improve performance.
Apply only on simple Visuals. Probably the most important advice here. If you want to apply an effect on a complex Visual, use layers! Apply the BitmapEffect on a simple Shape (e.g. Rectangle, Path), and use a Grid, for example, to position it below your complex Visual. Do not apply the effect on a Decorator (such as a Border) that contains your Visual, since that will cause the entire visual tree to suffer from the effect.
Avoid Animations. Especially on large Visuals, avoid animating the BitmapEffect's properties, and animating elements that have effects applied on them. TextBoxes, for example, animate the cursor frequently when they are focused, so if an element that has an effect contains a TextBox, it is forced to render itself entirely every blink.
Use Bitmaps. Yes, it's true bitmaps don't scale like vectors, but in some places they are a very viable alternative.
How nine-grid images work
Use Nine-Grid Images. Have you ever wondered how the themes on XP and Vista work? You can stretch a button as much as you like and it still looks good. They use nine grid images. The idea is very simple: divide the image to nine areas and stretch it as shown in the illustration. The effect is that the proportions of the corners and borders are always maintained. I've attached a project with a NineGridBorder class that can be used to draw these images. After I wrote it, I discovered another implementation, so I took the best of both of them.
Vectorize. When exporting from Expression Design to XAML, you have the option to either rasterize (i.e. create a bitmap) or vectorize some of the effects. For example, when applying soft edges to a vector drawing, ED exporter will create a Canvas that contains a few layers with different opacities, which will simulate the effect.
Use WpfPerf. This is a great tool that comes with the Windows SDK. You can use Perforator to detect whether your careless colleagues used BitmapEffects or other ill-advised features that may hinder your application's performance. Check "Draw software rendering with purple tint" to immediately view what causes problems. Try to resize the window or run animations while this is checked.

Give me back my ClearType

aelij — Sat, 03 Feb 2007 08:55:00 GMT

WPF has a separate ClearType rendering system, which is better than GDI's (mostly because it also does y-direction antialiasing; read more here and in the WPF Text Blog.)

However, there are some situations in which WPF cannot use ClearType, and has to resort to grayscale antialiasing (it cannot render aliased text because of its pixel independent architecture) which comes out pretty blurry for small text sizes, in my opinion.

Here's when WPF can't use ClearType:

Window/Popup AllowsTransparency = true. This creates an HwndSource with UsesPerPixelOpacity = true (i.e. a layered window.) All context menus and tooltips in WPF have this turned on with no trivial way of turning it off. More on this later on.
Visual (or some ancestor) has a Bitmap Effect. (Sidebar: You should really avoid using those on any complex Visual. They yield the worse performance. If you want a shadow under something, take an empty Rectangle or some other Shape, apply the effect on it and put it under the more complex Visual.)
Text from another Visual appearing in a VisualBrush.
Rendering a Visual using RenderTargetBitmap.
Setting the HwndTarget.BackgroundColor to Transparent (needed for extending DWM glass to client area.)

Also, there are registry settings that can enable, disable or configure ClearType, both system-wide and WPF-specific.

In Vista, ClearType is turned on by default, so WPF also uses it. In XP, however, it is not. And so by default WPF is rendering grayscaled text. From my experience, ClearType is better even on CRT monitors, so when I write WPF applications, if ClearType is off, I display a message recommending to turn it on, and make the WPF-specific registry changes.

Now, for my woes. Take a look at these screenshots:

The left one is with ClearType, the right one without. I hope the difference is clear. As I mentioned earlier, context menus, tooltips and combo box use the Popup class, which has the AllowsTransparancy set to true. This is hardcoded. The reason for this is obvious: the designers of WPF wanted you to be able to customize these windows as you saw fit. And it can truly be used to do wonderful things (see this styled tooltips example. Quite effortless, if you consider what you had to do to get this done in Win32.) But I think readability is more important in these cases. At any rate, this should be configurable.

Aside from the text issues, layered windows' performance is much worse than normal windows. Even under Vista, where they are hardware-accelerated, the menu highlight is lagging after the mouse sometimes.

Frustrated a bit, I came up with a somewhat dubious solution to these issues.

For ComboBoxes and MenuItems, I created an attached Dependency Property, which, when attached to a control, attempts to find the "PART_Popup" in its template and set its AllowsTransparency property to false. Caveats:

You lose the animation when opening a combo box (slide) or a menu (fade).
You lose the shadow.
If you apply a transform, the popup will not match it (Then again, who would want a skewed combo box? But a rotated menu might be useful.)

For ContextMenus and ToolTips, I create subclasses, overrode IsOpenProperty metadata and added an additional changed handler. The Framework Property Metadata documentation states that:

The actual property system behavior for PropertyChangedCallback is that implementations for all metadata owners in the hierarchy are retained and added to a table, with order of execution by the property system being that the most derived class's callbacks are invoked first. Inherited callbacks run only once, counting as being owned by the class that placed them in metadata.

Either I don't understand it well or the documentation is wrong, since the method I specified ran after the original method. To solve that, I wrote a class that inherits FrameworkPropertyMetadata and reverses the execution order, so I could create the Popup myself without setting the AllowsTransparency to true. Caveats:

I use reflection to get to private fields. Yes, I know it's bad... :P
Again, you lose shadows and animations.
Tooltips have rounded corners by default (at least on Vista) so you'll see gray 1-pixel dots on the corners. But you can change the tooltip's default style to get rid of this.

I tried to regain the shadows using cheaper means (CS_DROPSHADOW window class style) but it's difficult to reach.

You may think I'm crazy to go through all of that just for a few blurry texts, but I think this really impacts the overall readability of my applications.

Anonymous Comments Enabled

aelij — Sun, 19 Nov 2006 00:30:00 GMT

I didn't notice that when I set up the blog, anonymous comments were disabled!

I just enabled them, and I hope this won't lead to a spam attack. Maybe I should add a captcha, though I don't care much for that method.

Anyway, now you can feel free to comment on my posts. :P

Update: Comment spam was unbearable... Added this captcha. Still have hundreds of junk comments to delete :-|

I Got Rhythm Now Available in XBAP!

aelij — Wed, 15 Nov 2006 23:25:00 GMT

This is not quite ready, but I just had to give you a sneak peek:

http://arbel.net/blogx/blog.xbap

I believe this is the first blog presented in XBAP. The possibilities are endless... The tag cloud uses Kevin Moore's Bag-O-Tricks. The HTML is being rendered by a modified version of the Windows SDK Team's HTML to Flow Document converter.

I've written a Community Server web service that allows me to pull all the data and bind to it.

Note that this was compiled in RC1 (waiting for Vista RTM in MSDN) but it seems to work on .NET 3.0 RTM.