Just a couple of days ago Microsoft MVP lead Alessandro Teglia announced the newly awarded and renewed Most Valuable Professionals for 2009 — I would like to congratulate all of them on their achievements. Rock on!

I am also very happy and proud to be given the award for Visual C# this year. It is my programming language of choice and in my opinion the .NET Framework will continue to be adopted by developers in 2009. I hope the MVP program will offer a lot of new doors and opportunities.

So what’s to come on my blog? I plan on writing mosly technical posts about the .NET Framework as a whole, and coding patterns in .NET languages. Visual Studio 2010 is coming near release and it is going to introduce some very interesting additions, which I will go through in the coming days.

I am frequent on the official Microsoft newsgroups (mostly .NET-related) and will be attending Microsoft Days ‘09 later this month. You can expect an essential coverage as well.

Last, but definitely not least, a big “Thanks” to Microsoft and a very good friend of mine, Christoffer Andersson, for all the support!

P.S. I am contemplating mirroring some or all of the articles in Bulgarian, my native language. Are there any Bulgarian readers out here?

GlassLib is a wrapper library for the Desktop Window Manager API and is to be used by developers which would like their applications to take advantage of .NET Framework and Windows Presentation Foundation in particular.

It can be used to control the Desktop Composition due to application requirements, create and reference Live Thumbnails of arbitrary windows, manipulate the Glass client area of windows and receive events which occur for them (Figure). Developers who target their applications for Far East users can also use the wrapper library to control the flow direction of controls and caption bar.

While the library wraps a big portion of the API exposed by DWM, the timing and performance counter part is to follow up shortly.

Documentation and a test application are provided. The usage of the wrapper library is pretty much straight-forward. Following is a list of several key facts:

• Add a reference to the DwmWrapper.dll library to your project (from the Solution Explorer, select your project’s node, right click it and select Add Reference. From the new dialog box, browse the library file). Please note that the library is compiled against the .NET Framework 2.0 therefore it can only be used in projects compiled against it, or a newer version.
• Include the GlassLib namespace so that the Dwm-related classes can be accessed more easily.
• When used in a System.Windows.Window, override the OnSourceInitialized method and then set up the event handlers.
• Per-window options can be set using the Dwm.Glass, Blur, Events, NonClientArea and Flip3D. This is available by using the indexer (default property) of these properties. The value passed to the indexer can be an IntPtr - handle to a window or a System.Windows.Media.Visual whose window handle will be manipulated. E.g:
• In VB .NET: Dwm.Glass(Me).Enabled = False
• In C# .NET: Dwm.Glass[this].Enabled = false;
• Note: this and Me refer to the calling instance, which is a System.Windows.Window in the example.
• The Dwm* structures have implicit operators. This allows for casting Windows Presentation Foundation Rect and Thickness implicitely to DwmRect and DwmMargins, respectively. For instance, the following expression will be valid:
• Thickness foo = new Thickness(5, 30, 5, 20);
  // Assign foo to a Visual’s margin.
  Dwm.Glass[this].Margins = foo; // foo is implicitely casted to DwmMargins.

Following the first part of the Tweak DWM from your programs series, we are going to explore the actual usage of the Desktop Window Manager API in a Windows Forms-based program. The test application–included in the source package–also makes use of GlassBar, an extension to the existing control set.

Using GlassLib in your program

GlassLib is going to be main focus of this part of the series. It supersedes DwmWrapper by implementing a framework around GlassBar which can be used as a complement to your visually-rich forms. In order to use this library in your project, you have to do the following:

1. Include a) a reference to the DLL in your project from Visual Studio: Project menu => Add reference, or b) the actual code files to your C# project (adding them as links (shortcuts) as opposed to copying them is more suitable if you wish include the files in multiple projects and/or wish to make changes to the code yourself).
2. Remember that all of the functionality lies in the GlassLib namespace. You can use the using or Imports clause in the beginning of your C# or VB.NET code file, respectively, or the global imports if you code exclusively in VB.NET.

Exploring the GlassLib Test app

Let’s begin exploring the framework by opening the project file for GlassLibTest. Included in the GlassLib solution, it depends on the GlassLib project reference, which on its part has all the DwmWrapper code. Open the frmMain.cs file which is the form which is to be executed right at start up. As described in the first part, the first thing the class constructor public frmMain() should do is to set Dwm.ThrowExceptionTypes to DwmExceptionTypes.None in order to avoid any exceptions from being raised when DWM is not enabled or available on the OS, or if any function failed. The next thing the program does is to enable dragging from the Glass-extended area.

Dwm.Glass[this].DragExtendedArea = true; is useful if you want the extended area to act as the caption bar does, like in Windows Media Player. This is what the GlassBar toolbar does as well (more on this later in this part). Switch to Designer mode (View => Designer) and you can see the layout of the form: the usual Windows Forms buttons, combo and text boxes et cetera, but also GlassBar. To add the latter to your own forms, open the Toolbox (View => Toolbox) and drag it to your form (see figure on right). The toolbar will automatically dock to the bottom of it and extend Glass from this side of the form. You are free to dock it to the whole form (or container for that matter) or one of the other sides. Because DWM only supports Glass on top-level windows, in designer mode GlassBar falls back to UXTheme API in order to get the theme-specific background image or brush which is suitable for all non-Aero Glass themes such as Aero Basic, Luna (on Windows XP) or Windows Classic on any supported Windows version. On top of this, you can choose to write your own GlassBarRenderer.

This feature provides two key benefits to your application’s design:

• For Windows Vista systems and future OS with support for Glass: rich, seamless Glass UI
• For Windows Vista systems where DWM is disabled or unavailable, and all previous Windows releases: seamless UI deriving from the appropriate Windows theme, including custom themes created with software such as WindowBlinds.

Managing the GlassBar items

Adding your items to GlassBar is quite easy. While in Design Mode, make sure that the Properties pane is visible (View menu => Properties Window to invoke it), select Items and expand the Collection Editor. You can add, remove and rearrange the items. For each one of them you can customize their:

	Name	Used in code only (does not appear in UI)
	Enabled	Enables/disables the item from the UI
	Icon	Preferably translucent PNG image 25×25 pixels in size
	IsSeparator	Denotes whether the item is a separator (its Icon will be disregarded)
	Overlay	Image, useful for ‘hover’ effects
	Text	Alternative text shown when the item is hovered
	Visible	Shows/hides the item

You can of course manage items programmatically using the Items property, for example adding one: Image img = Image.FromFile(“someFile.png”); GlassBarItem gbi = new GlassBarItem(“Sample Text” + i, img); glassBar.Items.Add(gbi); When the logic of your program requires an item be disabled or hidden, e.g. an unavailable feature, you can use Enabled or Visible to prevent users from clicking it.

Custom renderers

Internally GlassBar defines a standard renderer which on Windows Vista with Aero Glass enables draws on a translucent surface and otherwise falls back to the system-defined theme. If you wish to code a custom renderer for your needs, what you have to do is:

1. Create a class deriving from (inheriting) from one of the following classes:
   • GlassLib.Rendering.DefaultGlassBarRenderer if you wish to customize only specific parts of the default renderer (images, background etc)
   • GlassLib.Rendering.GlassBarRenderer if you wish to build one from the ground up. This requires you to implement all of the methods and properties and is unlikely to be your choice.
2. Decide which functions or images you would like to change. You can assign any image to MainPiece, RightSecondaryStates, AnimationStrip etc.
3. The DrawBarBackground function is called every time the UI changes and needs to be redrawn. It is here where you can change most of the behavior of the default renderer and implement your own features.
4. Assign an instance of your custom renderer to GlassBar
   • glassBar.Renderer = new CustomRenderer(); or to revert to default:
   • glassBar.Renderer = new GlassLib.Rendering.DefaultGlassBarRenderer();

The test app

There is a test program added to the package, GlassLibTest, whose code and compiled binary you can explore and experiment with GlassBar and DWM. If you have any comments, questions, wishes or just an opinion, I would be happy to hear it.