I got a couple questions about how I made the Aero Glass effects in GlassCalc. When I started making GlassCalc, I had no idea how to manage Aero Glass, but Google came to my rescue. What I eventually came up with is the amalgamation of code snippets and general knowledge from countless separate articles and examples. I’ll link to as many of those pages as I can remember, but I’ll try and bring everything together in one place here.

Note: GlassCalc is written in C# using WPF for its UI. As such, some of the code examples below are C#, .NET, or WPF specific.

Every window in Windows has a client area and a non-client area. The client area is everything you get to handle and draw on. Normally, this is everything inside the window frame. The non-client area is everything Windows handles by itself: the window frame, icon, window title, min/max/close buttons, resize handles, etc…

Using the Windows API, programs can modify the glass frame and the client/non-client areas. Generally, they either extend the glass frame into the client area, or they extend the client area into the glass frame. GlassCalc does both.

With the default interface, GlassCalc extends the top and bottom of the frame. The client area is still the same size, but the glass frame has been extended into the client area, so GlassCalc can draw the menu and the input box over glass.

[singlepic id=6 w=320 h=240 float=center]

With the full glass interface, GlassCalc extends the frame to cover the entire window, so everything is drawn over glass, but it also draws the menu bar inside the title. This is done by extending the client area upwards so GlassCalc can draw there. This effect takes quite a lot more work, because now that GlassCalc has taken over the non-client area, it must handle all the things Windows used to handle in this area.

[singlepic id=13 w=320 h=240 float=center]

Extending the glass frame

All of the code here involves Windows API calls in some way. To organize everything, I’m putting all Windows API functions and structures in a class called Interop. (some examples use the name NativeMethods) I’ll also make a class called GlassHelper which will (quite appropriately) help deal with Aero Glass.

To extend the glass frame, we need to import a function called DwmExtendFrameIntoClientArea from dwmapi.dll. Since Aero can be disabled, we also need to know whether we can extend the frame or not. For this, we import DwmIsCompositionEnabled. DwmExtendFrameIntoClientArea takes a Margins structure as one of its arguments. Since there is no Margins structure in C#, we need to define it ourselves. Much of the following code comes from this informative article.

Note: You can copy the source of these code examples by hovering over the code, then clicking the view source icon in the toolbar that appears in the upper-right corner.

public static class Interop
{
    [StructLayout(LayoutKind.Sequential)]
    public struct Margins
    {
        public int Left;
        public int Right;
        public int Top;
        public int Bottom;
        public Margins(Thickness t)
        {
            Left = (int)t.Left;
            Right = (int)t.Right;
            Top = (int)t.Top;
            Bottom = (int)t.Bottom;
        }
    }
    [DllImport("dwmapi.dll", PreserveSig = false)]
    public static extern void DwmExtendFrameIntoClientArea(IntPtr hwnd, ref Margins margins);
    [DllImport("dwmapi.dll", PreserveSig = false)]
    public static extern bool DwmIsCompositionEnabled();
}

Now, we’ll make a class that can make use of these functions.

public static class GlassHelper
{
    /// <summary>
    /// Gets whether dwmapi.dll is present and DWM functions can be used
    /// </summary>
    public static bool IsDwmCompositionAvailable
    {
        get
        {
            // Vista is version 6.  Don't do aero stuff if not >= Vista because dwmapi.dll won't exist
            return Environment.OSVersion.Version.Major >= 6;
        }
    }
    /// <summary>
    /// Gets whether DWM is enabled
    /// </summary>
    public static bool IsDwmCompositionEnabled
    {
        get
        {
            // Make sure dwmapi.dll is present.  If not, calling DwmIsCompositionEnabled will throw an exception
            if (!IsDwmCompositionAvailable)
                return false;
            return Interop.DwmIsCompositionEnabled();
        }
    }
    /// <summary>
    /// Extends the glass frame of a window
    /// </summary>
    public static bool ExtendGlassFrame(Window window, Thickness margin)
    {
        if (!IsDwmCompositionEnabled)
            return false;
        IntPtr hwnd = new WindowInteropHelper(window).Handle;
        if (hwnd == IntPtr.Zero)
            throw new InvalidOperationException("The Window must be shown before extending glass.");
        HwndSource source = HwndSource.FromHwnd(hwnd);
        // Set the background to transparent from both the WPF and Win32 perspectives
        window.Background = Brushes.Transparent;
        source.CompositionTarget.BackgroundColor = Colors.Transparent;
        Interop.Margins margins = new Interop.Margins(margin);
        Interop.DwmExtendFrameIntoClientArea(hwnd, ref margins);
        return true;
    }
}

Finally, in override your application’s OnSourceInitialized method to call ExtendGlassFrame. The Thickness object you pass in defines how far in the frame should be extended from each of the sides. If you use -1 for each dimension (like in the code below), the glass will cover the entire window.

public sealed partial class YourApp : Window<
{
    . . .
    protected override void OnSourceInitialized(EventArgs e)
    {
        base.OnSourceInitialized(e);
        GlassHelper.ExtendGlassFrame(this, new Thickness(-1));
    }
    . . .
}

Make the glass area act like an extension of the title bar

If you extend the frame from the top such that the title bar appears bigger, (like in the default GlassCalc interface) you probably also want to make it so that when a user clicks in this empty area, they can drag the window. You can do this by detecting a MouseLeftButtonDown event inside the extended title bar area and calling your window’s DragMove function.

What if Aero gets disabled while my program is running?

There is one other thing you should take care of when extending the frame. If a user turns off Aero while your application is running, you’ll get big black areas where there used to be glass because your window background is transparent. Windows sends a WM_DWMCOMPOSITIONCHANGED message to your application when Aero is turned on or off, so you can handle this by setting up a function to listen for this message.

Add this constant to Interop.

public static class Interop
{
    public const int WM_DWMCOMPOSITIONCHANGED = 0x031E;
    . . .
}

Now, set up a function to listen for messages. When it gets a WM_DWMCOMPOSITIONCHANGED message, check to see whether Aero was enabled or disabled. If Aero was enabled, extend the frame again. If it was disabled, set the background color back to its original value. (This example assumes your window background was white. You could improve it by saving the background color before extending the frame, then reverting it when Aero is disabled.)

public sealed partial class YourApp : Window
{
    . . .
    /// <summary>
    /// Processes messages sent to this window
    /// </summary>
    private IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
    {
        if (msg == Interop.WM_DWMCOMPOSITIONCHANGED)
        {
            if (GlassHelper.IsDwmCompositionEnabled)
            {
                // Aero was re-enabled.  Extend the glass again.
                GlassHelper.ExtendGlassFrame(this, new Thickness(-1));
            }
            else
            {
                // Aero was disabled.  Reset the window's background color to remove black areas
                HwndSource source = PresentationSource.FromVisual(this) as HwndSource;
                source.CompositionTarget.BackgroundColor = Colors.White;
                this.Background = Brushes.White;
            }
        }
    }
    protected override void OnSourceInitialized(EventArgs e)
    {
        base.OnSourceInitialized(e);
        // Hook up the WndProc function so it receives messages
        HwndSource source = PresentationSource.FromVisual(this) as HwndSource;
        source.AddHook(WndProc);
        GlassHelper.ExtendGlassFrame(this, new Thickness(-1));
    }
    . . .
}

Extending the client area

Since this is already a very long post, and the part on extending the client area will probably be even longer, I’m going to split it up. Extending the client area into the frame will come in part 2… whenever I get around to writing that. For now, here are some of the links I found most useful while figuring this stuff out.

• A nice article on extending glass frames: http://blogs.msdn.com/b/adam_nathan/archive/2006/05/04/589686.aspx
• Great article on window chrome: http://blogs.msdn.com/b/wpfsdk/archive/2008/09/08/custom-window-chrome-in-wpf.aspx
• How I figure out DLL imports and Windows API constants: http://pinvoke.net
• Google is my friend.

Update 8/19/2010: I know it’s been over a month since I posted part 1, and I still haven’t gotten to part 2.  I’m working on it, but school is start back up, so I can’t say when it’ll be done.