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.

Mary-Jo Foley posted an entry saying that Microsoft was planning to skip the next logical in-band server release, Windows Server 2008 R2, and go straight to Windows Server 7. This created quite a discussion among some techies, wondering why they would skip this release.

I personally had mixed feelings on this situation. I said on one of the tech forums I visit,

There’s only ever been one R2 release, and that was for Windows Server 2003 (and all it’s various sub-SKUs). That was because they had features to release, but no major platform to build it on. Consider that when WS2003 R2 was released, the latest build was the Pre-Beta 2 5259. There were also several other large platform launches that year - Visual Studio 2005 and SQL Server 2005. Now in 2008, this “big-three” was revived - Windows Server 2008, Visual Studio 2008, and recently, SQL Server 2008.

Also, I think 2010 seems to be on track for Server 7, as that would follow their schedule they’ve kept for a while now, and would confirm the late-2009 client release.

Apparently, Mary-Jo was later told by Microsoft that Windows Server 2008 R2 is on track to become the next version of Windows Server. Supposedly this release is on track for 2010, immediately parallel to the next client release, Windows 7. Then another version, “which may or may not be called Windows Server 7″ is expected in 2012. This would leave Microsoft in a somewhat regular pattern, as seen in the below timeline.

Timeline of Windows, Windows Sever, Visual Studio, and SQL Server 2002-2012

More of my own analysis of the recent events, along with a quick versioning primer, comes after the break.

Updates Here, There, Everywhere: A Review

Near the beginning of the decade, Windows Server 2000 and SQL Server 2000 were holding steady in their own markets. Windows XP had just been released on the Windows Client side. Then there was the release of the .NET framework.

In 2003, two important systems were updated - Windows Server and Visual Studio. They both contained the year “2003″ in their title. 2004 became an off year (at least in terms of major releases, since XP SP2 did release to web in 2004), though as many AeroXperience readers may remember, Longhorn was originally slated for a possible 2004 release. Then in 2005, developers got a large update with both Visual Studio and SQL Server releasing new versions, again versioned by year. No major Windows updates were shipped that year.

Things changed in 2006, with no updates coming to the developer tools, but Windows Server 2003 R2 coming in early February and Windows Vista RTM’ing in November. Windows Server 2003 R2 became basically, the “2005″ update to Windows Server, matching it with the other two “2005″ products.

The developer trio reunited in late 2007-early 2008 with the release of Visual Studio 2008, then Windows Server 2008, and finally SQL Server 2008 last month.

So by now, you’re surely wondering, “Why is this important?” Because, by looking to the past, you can also see the future. Graphically, we can see that Windows Server is on a regular release schedule, as is Windows client (although it seems to be nearly twice as long). The next meeting of those two has been confirmed by Microsoft, and is set for 2010, many guessing early in that year. So that also means, don’t be surprised to see the next version of Visual Studio (VS10 or “Hawaii”) and/or SQL Server. However, don’t be surprised if they don’t come out until later in the year and are named with the year “2011″ as to fit with the last three big launches.

Windows 7 Not As Important?

A Microsoft spokesperson has also confirmed several things about Windows 7 and Windows Server 2008 R2 Windows 7 Server. For one thing, he says that Windows 7 is not actually Windows version 7, but actually version 6.1. So basically,  Windows 7 (NT 6.1) is to Windows Vista (6.0) as Windows XP (NT 5.1) was to Windows 2000 (5.0). The architecture changes aren’t too great (though from what it sounds like, there may be less in Vista->7 compared to 2000->XP. This also explains why in the few leaked screenshots we’ve seen, WinVer lists Windows as Version 6.1. The confusion comes from the codename “Windows 7″, since there appears there’s going to be another, true Windows 7 at some point. It may just end up confusing geeks who care about numbers, but it has the potential to confuse more than that (you know what technological leaks can turn into in mainstream media).

Editor’s note: while the kernel revision numbers are important, they’re mostly used for application compatibility purposes. More significant revisions are more likely to break older applications, so the major revision number is generally updated in the event of significant change. It’s possible to have a kernel with many added features while only being a minor revision increment (6.1 as opposed to 7) simply because not enough old features were changed or scrapped.

Big Bang, Minor Maintenence

It also appears that Microsoft may be wanting to make their Windows client more like their Windows Server in more ways than one. This seems to be a good thing; many people have sang high praises for Server Core, so a similarly modularized Windows client operating system will likely receive the same approval. They also seem to want to bridge together Client/Server release timings, which in my mind makes a lot of sense. Sure, giving it more time to bake ensures some more errors get worked out, but if you release a new client and then put it on an old server, it may not necessarily work as well on the old server as it would on the new one. (Note that I haven’t done enough testing with Vista+WS2003 vs Vista+WS2008 to say if that applies here. If you do have an opinion on that, duke it out in the comments.)

It also seems they may be doing this to keep it on a major/minor release cycle. We had Win 2000/Win XP, and now we’ll have Win Vista/Win 7. As mentioned earlier, this same thing happens in the Server world under the guise of R2 releases.  All in all, the numbers aren’t important, and really, not even the dates as much, if what we get is a quality product. It’s fun to follow all the small stuff, but remember, it’s the big stuff that sells.

With Windows Vista, Microsoft introduced a whole new window manager which provides a better experience to the user and an independent graphics surface to us developers by taking advantage of graphics acceleration hardware (your graphics card or integrated GPU).

In a three-part blog post, I will show you how to use a wrapper around the Desktop Window Manager Application Programming Interface in order to control its state, change colorization, or change the rendering policy of windows from your Windows Forms and .NET 3 Presentation Foundation programs.

Getting Started

Windows Forms and Windows Presentation Foundation will be referred to in these posts as WF and WPF respectively.

The code you will need can be downloaded from here and is written in C# (as are the code samples in this post). That being said, you can use it in projects of any other .NET language — you can include the compiled libraries as references. Otherwise (if you code in C#), you also have the option to include the files in your project and not distribute a separate library. The solution is for use in Visual Studio 2005 but is also compatible with version 2008.

The whole framework is located under the GlassLib namespace and is the source to three main types of projects:

• DwmWrapper is a .NET wrapper around the DWM API, which can be compiled in the following flavors:
  • No dependency on WF or WPF. It can be used to avoid DLL clutter when coding command-line applications to manipulate the DWM.
  • Solely WF or WPF
  • Both for mixed-framework projects.
• GlassLib is a WF-powered layer above DwmWrapper and provides a set of classes, including the GlassBar control for use in your forms
• The Test Projects you can use to try the various features that the two other projects have. They will be used here ad hoc.

In this first part, we will explore the architecture of the wrapper, its core functionality and application in Windows Forms programs.

Microsoft provides an API for DWM in the equivocal DwmApi library. Encapsulating it for easier use in .NET programs is the wrapper’s main purpose.

Since all necessary classes are located under the GlassLib namespace, in order to avoid writing it every time, I would suggest that you insert it in your C# or VB code file’s “imports” or, if you are working exclusively with VB, in your project’s “Imported Namespaces” list in order to avoid doing the first as well.

The most important class is Dwm and can be used to control virtually any aspect of DWM as long as the public API allows it. The various features are available via the following properties of Dwm:

	Blur	Enables/disables the black background transition when a window (not necessarily your window) is maximized, sets custom blur region
	Colorization	Gets/sets the Aero Glass colorization
	Composition	Enable/disable DWM, check if running and if the system is DWM-capable
	Events	Used to set up notifications for colorization, composition, non-client rendering or window-maximized changes
	Flip3D	Start/Stop Windows Flip3D or Flip
	Glass	Enable/disable Glass on a given form (via its instance, e.g. this) or window (via its handle/hWnd, an IntPtr)
	NonClientArea	For advanced users only, gets or sets how DWM is handing the painting of a given form or window (see Glass above)

Using the Wrapper

Note that DWM is only available on Windows Vista, so I would suggest that you select how to handle the wrapper’s behavior on earlier operating systems. Otherwise, exceptions will be raised which you will have to catch.

The first option is to limit the exceptions the wrapper will raise by setting Dwm.ThrowExceptionTypes to one of the available DwmExceptionTypes

	None
	UnsupportedFeatures
	DesktopWindowManager

Raising no exception will most likely suit your needs best so adjust this property before you make any other changes to DWM, preferably at program startup or in the form’s constructor.

Dwm.ThrowExceptionTypes = DwmExceptionTypes.None;

Now you can make any changes you want to your form’s state in the DWM, for example enable Glass–it is as easy as writing

Dwm.Glass[this] = new DwmMargins(100, 4, 8, 20);

where this is the instance of the form (you can replace this with any other form instance you would like) and the margins are defined as left-right-top-bottom. You can use DwmMargins.EntireWindow instead to extend glass in the whole window client area, like Mobility Center does in Windows Vista.

Restoring the default borders is done by calling the Restore method.

Dwm.Glass[this].Restore();

Receiving notifications on the global DWM state or on your forms’ is important in order to know how you should handle painting backgrounds or the non-client area. You can choose to get notified when the Aero Glass colorization is changed or DWM starts up or shuts down. In GlassLib this is straightforward: each form that you wish to be notification-aware, GlassLib will include in its list and you have to attach your handlers to the colorization, composition, non-client rendering or window-maximized changes.

Dwm.Events[this].AddHandlers(); // Notifying GlassLib…

// Add our handlers

Dwm.Events[this].CompositionChanged += new DwmEventHandler(OnCompositionChanged);
Dwm.Events[this].ColorizationChanged += new DwmEventHandler(OnColorizationChanged);

…

private void OnCompositionChanged(object sender, DwmEventArgs e)
{
// Update the UI on composition change (extend glass if DWM is enabled, otherwise restore)
if (Dwm.Glass[this].Enabled)
Dwm.Glass[this].Margins = new DwmMargins(100, 4, 8, 20);
else
Dwm.Glass[this].Restore();
}

private void OnColorizationChanged(object sender, DwmEventArgs e)
{
MessageBox.Show(e.Colorization.ToString());
}

Although the public DWM API does not make it easy for one to change the colorization programmatically, DwmWrapper exposes this functionality through the Dwm.Colorization property. Controlling the Desktop Window Manager is also as easy as setting Dwm.Composition.Enabled to the desired value, either true or false. Other useful “one-liners” include invoking Windows Flip and Flip 3D: Dwm.Flip3D.EnterAltTab(); and Dwm.Flip3D.Enter();, respectively.

You can tinker with the full GlassLib source code and the included test projects to see how all of the aforementioned features work in a real environment. In the next part I am going to cover the more advanced functionality of the wrapper, the Windows Forms test app and how it manages DWM thumbnails.

If you have any comments, questions, wishes or just an opinion, feel free to post it here.

Part 2 coming soon…

You are free to use GlassLib in your freeware programs, but please at least acknowledge it in your release notes/about dialog/website. In case your program is commercial/shareware, I would appreciate it if you could contact me beforehand. Thanks.

(This is the first in an ongoing series about PDC 2008)

While perusing the PDC 2008 website’s preliminary agenda, I came across two sessions that really caught my attention:

Windows 7: Graphics Advances
Windows 7 enables you to advance the graphics capabilities of your applications while carrying forward existing investments in your Win32 codebase, including GDI and GDI+. New enhancements to DirectX let Win32 applications harness the latest innovations in GPUs and LCD displays, including support for scalable, high-performance, 2D and 3D graphics, text, and images. Also learn how to leverage the GPU’s parallelism for general-purpose computation such as image processing.

and

Windows 7: Web Services in Native Code
Windows 7 introduces a new networking API with support for building SOAP based web services in native code. This session will discuss the programming model, interoperability aspects with other implementations of WS-* protocols and demonstrate various services and applications built using this API.

After reading these, I could come to only one conclusion: Microsoft is building an unmanaged version of WinFX (at least the WPF and WCF components of it), currently known as .NET Framework 3.0.

This isn’t the first we’ve heard of this. Long first revealed a job description back in March that related to a new, native UI framework for Windows 7. The PDC session overview doesn’t add much (outside of the WCF component) to what was revealed there, but it does seem to indicate that this framework hasn’t been cut from Windows 7.

A native WinFX excites me for many reasons. One reason is that it opens up the robustness of the Windows Presentation Foundation (WPF) to native developers, most likely with a significant performance gain versus the current managed WPF developers use now.

Also, according to the job description, this framework will use a markup language to define user interfaces (Most likely XAML or something extremely similar), which means designers will be able to use their knowledge (and code) across Win32, .NET and Silverlight now. This could speed adoption of all three technologies, which is nice.

Perhaps the most exciting things to the average user are the possibilities this offers up to Microsoft for Windows 7 itself. Microsoft jettisoned most of its vision for a graphically rich shell when it reset Longhorn development and realized that building Explorer in .NET and on top of a framework that was still in development was a bad idea. Now that this framework (milcore) is done, Microsoft should be able to harness its power rather easily through this new unmanaged WinFX framework without having to completely rewrite Explorer.

In other words, much of the UI goodness from the early Longhorn prototypes could wind up in 7.

Here’s hoping, anyway.

The last couple of weeks, I have been working incredibly hard on a tool to create Vista Style Builder. Vista Style Builder supports everything that is needed to create Visual Styles for Vista:

• Import and export images
• Change, add or remove properties
• Import and export STREAM images
• Compile into a totally new MsStyles-file

In this post I will highlight some details of Vista Style Builder (VSB) which show how much easier this application makes it to edit MsStyles.

The Main Window

Most of the time when creating Visual Styles, you will be looking at the main window of VSB. This main window exists basically of four parts:

• The command bar in the top of the window to do things
• The UI parts browser on the left which displays every UI part in a MsStyle neatly grouped into categories
• The Preview pane, which will show the images used in a UI part
• The property view in the bottomright, showing an editable list of all properties for a UI part

As you might notice, there is no menu bar anymore. In line with most Vista applications, VSB uses a commandbar for all possible actions that can be done.

Importing Images

VSB allows a user to export the images used in a Visual Style in order to edited the images in an external application, such as Adobe Photoshop. It is possible to export a strip of images (e.g. all different button states in one image), but it is also possible to just export one state of an image (e.g. the button-pressed image).

Importing is done in a similar fashion: you can import an image with all states or just one state directly. VSB always provides a default name for importing and exporting, so if you follow that naming schemes, you can quickly import and export images.

VSB will notice it if you try to import an image of different dimensions than the original; it will actually ask you what you want to do:

Alpha Channel Importing

One of the problems people are currently facing with Vista Styles is that photoshop and Vista uses a slightly - or so it seems - different format: the alpha channel comes out wrong in MsStyles for files imported manually.
Vista Style Builder fixes this incompatibility when importing images.

Adding Properties

Another feature in VSB is the possibility to add new properties to UI parts. This makes it possible, for example, to give the taskbar fonts a glow or even make the breadcrumb bar glow.

Properties are added through a easy to use dialog which allows you to select the type of property (e.g. enum or color), the name (e.g. iconeffect or textcolor) and the value. For enumeration-types, such as Iconeffect, a listbox will automatically show all possible values.

StyleHacks

People often want to change the same things in their Visual Styles. Some good examples are a thinner taskbar and a small startmenu. Most of the time, these things involve editing a number of properties in some unexpected way.

To make it easier for everyone to use often done things in their styles we invented StyleHacks in VSB. A StyleHack is an easy way to apply an often done thing (a`hack`) to your Visual Style. For example, there is a StyleHack to change the height of the taskbar to 18px.

Visual Style Builder provides an in-application menu to browse the available StyleHacks with a preview image and apply them with a click of the mouse:

Import XP Styles

A featue of Visual Style Builder that has been secret until now is the ability to Import XP MsStyles.
That’s right, VSB makes it possible to use your favorite XP Styles on Vista! Most XP Styles only need some small modifications after importing to work correctly on Vista .

Here’s an example of XP Luna after having it converted to a Vista Style after importing:

As you can see, the dialog uses the Luna window borders as well as Luna buttons. As a bonus, the Luna theme got dropshadows and is rendered by the DWM. For this theme, I opted to keep the Aero buttons because I personally think they look great on the Luna theme.

Of course, not all themes can be imported 100% correctly: Vista has some more restrictions on the window frames than XP had. However, it will make porting much easier and it works for a lot of themes without modifications.

Availability and price

The big question is now when will VSB be available? Unfortunately, I can’t really give a date yet. The technical side of the application is completely done; the business side, however, is not.

I know a lot of people expect this application to be free, but I can tell you that it will not be free. There went a lot of work in VSB and, at the very least, I need to earn the invested time back.

Editor’s Note: A distribution policy for Vista Style Builder and AeroXperience members is currently being researched

I can give a pretty interesting perspective on the Windows 7 leak, considering said perspective is coming from someone who has had this build for 3+ months as of the writing of this post.

Before I really jump in, I should explain why leaks of this magnitude are bad. Believe it or not, these leaks do hurt Microsoft and the dev process of the operating system, especially this early in the cycle. When a leak happens, Microsoft has to devote time to investigating the leak and trying to pin down a source, ultimately the internal source or OEM who leaked it. Leaks are also bad because there are just some things that aren’t ready to be seen outside of Redmond yet, especially by the average Joe user. Say a build leaks, and average Joe doesn’t like a certain feature, or even more realistic, finds a real nasty bug. He blogs about that and next thing you know everyone is jumping on the slingfest bandwagon and presto, bad image before the product is even out of the gate.

The main thing about the 6519 leak that gets me is the fact that it leaked after so much time. I can only assume that it came from someone in the group that got the build about a month ago, and for some reason was looking for a “15 minutes of fame” moment. There is, however, a silver lining to all of this. The build is hard coded to expire on June 6th, after which date the activation system will lock you out of the system. Why someone would leak after expiration, you ask? Well it’s actually a pretty simple answer. They get their little moment of fame and (they think) cause little damage to Microsoft since Joe user can’t use it on a daily basis. The fact is though, the beta community is rather unique, we take builds of OS’s and actually use them on our machines to tinker with and see the direction that Microsoft is going with the future of Windows. With 6519, running on the current date is now impossible, but the OS can be used if you set the date back before expiration, which some will probably be willing to do, just for bragging rights.

I guess the point I am trying to make with all of this is 6519 never should have been leaked, but it is the unfortunate fact that we have some people in this community that just can’t seem to keep anything under wraps and thinks that leaking a build will gain them some kind of celebrity status. That could not be more inaccurate. Within the last few years leakers have been looked upon as the black sheep in the community, for the exact reasons that I mentioned earlier. The fact is that these people will never learn, and will likely continue to do things like this.

News broke this week that a number of senior Yahoo engineers are leaving. Despite the fact that all of them stressed that their walkouts have nothing to do with the now-failed Microsoft merger, there’s a good chance that that’s probably what it is. Let’s take a quick look at why the departures of Jeremy Zawodny, Jeff Weiner, and others are related to the fallout of a failed Microsoft buyout and the problems Google poses to some of Yahoo’s best engineers.

Yahoo is well known as a popular web property. While many people in the United States and Europe have Google set as their homepage, Yahoo is a hot landing spot for many non-western nations such as China. Yahoo also knows how to maintain the communities formed by the Web 2.0 startups they pick up. One good example is Flickr; it’s is still popular with many photographers despite being owned by a monolithic and arguably uncool parent company. Del.icio.us is also roughly as popular as a social bookmarking service as it was when it was purchased by Yahoo. The engineers which Yahoo picked up with these acquisitions have also been put towards a number of other projects, which may have been part of the reason for the acquisitions in the first place besides expanding the Yahoo brand name.

Picking up knowledgeable engineers may have also been part of the reason behind the Microsoft-Yahoo merger. Besides the engineers which would come along with such a buyout, name placement in those eastern markets as well as popular and well-maintained Web 2.0 services serve as a very healthy set of bonus reasons for a rather expensive merger.

A number of analysts and commentators have also speculated that the buyout offer may have been put forward as a means of pushing the company towards disarray and, subsequently, towards a mismanaged doomsday. Microsoft has used buyout proposals for this purpose before, and Yahoo’s board might have kept this (and ego) in mind when trying to negotiate a higher per-share price.

How does this relate to the engineers? Microsoft has a number of interesting research programs. While Yahoo’s engineers might loathe the idea of working for a “mundane” product such as Windows or Office, Microsoft’s research programs offer new opportunities for developers to branch out into brand new fields and markets, something which Yahoo currently doesn’t have in place. On the other hand, Google has let a number of their acquisitions stagnate (blogger, now nothing more than a spampool, is the largest example.) without any significant overhauls, and their research programs remain mostly on the web as opposed to spreading into new fields.

Creativity isn’t often a word associated with Microsoft, but Microsoft is much more well established in a multitude of fields than both Google and Yahoo. This may be the primary reason behind the departures of some of Yahoo’s best minds. Jeremy Zawodny, after all, is one of the most well-respected R&D engineers Yahoo ever had, and and his attraction towards a small up-and-coming firm is representative of the new environments many of Yahoo’s engineers are interested in.

It’s been roughly seven and a half years since Microsoft released Windows XP to the masses in October 2001. Meanwhile, it’s been a little short of a year and a half since Vista first became widely available. However, many people, myself included, are still running Windows XP. Some people don’t like the changes in the new OS, while others like me just see no reason to shell out the money and buy it. Windows XP has served us well, and many would like to keep it that way.

I personally have always maintained that I would jump to Vista in a heartbeat if we got a machine, but that time hasn’t come yet, and frankly, for my pocketbook’s sake, I’m glad. There are some, though, who still want to get Windows XP when they buy a new machine. I’m not about to jump into a big debate on the topic – it’s just the way it is.

Many computer manufacturers took to expected approach in early 2007 of going “Vista-only”. People asked to get XP back, and many companies (Dell especially comes to mind) went and offered it up again. Microsoft then came out at a later time and said that they would continue offering XP to OEMs and at retail until June 30, 2008 – the end of the month. Some were maddened by this, wanting still to stick with XP.

While I was browsing around last week, I came across this interesting gem on a local computer shop’s web site:

Now as the image says, this shop is no small little thing, they are Microsoft Gold Partner and have close ties with Intel as well. However, I found it interesting that one of the biggest computer manufacturers, Dell, would stop selling XP on new systems on June 18, while this small shop could sell it until January 2009. It now appears that Dell figured it out, and mooted the point made in the above image.

According to a story on Neowin, Dell is now going to offer Windows XP Professional on new computers through “at least 2009 and likely longer.” The story mentioned that this means either Dell stocked up on a “year’s worth” of licenses, or is preceding an announcement by Microsoft saying that XP Pro will continue to live on. Note that Dell is not forgetting Vista here – they are including both media so that users can upgrade when they’re ready. Is it a smart move on Dell’s part? It would appear so at first. I mean, it will surely make people happy, at least those not sure if they’re ready to take the plunge yet

But come on, it’s been 16 months since Vista hit the shelves and some people are still not ready to give up XP? If you’re going to miss a car 16 months after you sell it, or call your son or daughter every day, twice a day, for 16 months after they move out of the house, people will: a) think you’re crazy, and b) in the case of the children, probably hurt you, or at least get rather irritated. However, it’s a completely different story here, and I’m not convinced it should be. Service Pack 1 is here, and although it’s not a huge “life saver”, it is a service pack. This is the magic milestone many people wait for (just look back over comments concerning Vista’s launch). And then look back further. I’m sure there was a transfer period with 2000/98/Me to XP, but was it over a year long? It surely wouldn’t seem to make sense.

The “magic” Service Pack 1 for Windows XP was delivered on September 9, 2002, about 11 months after it became generally available. For Vista, SP1 came on February 4, 2008, literally just 5 days after its one-year anniversary of general availability. So while it was a little longer development time, it still launched five months before XP is to “die”. I think that’s plenty of time to get adjusted.

Wired has an interesting article on how the iPhone boosted smartphone sales for other manufacturers (most notably RIM and Palm). With the next version of the iPhone now released, you might be asking yourself

• What will Microsoft do to keep Apple from breaking into the enterprise smartphone market?
• Why haven’t I bought this new iPhone yet?
• What’s that pretty thing in the Crystal Ball?

Now might be a good time to analyze the potential impact Apple’s iPhone might have on Windows Mobile.

The current version of Windows Mobile is version 6.1… which is still based on Windows CE 5.2 despite the release of Windows CE 6.0 back in November of 2006, which is well over a year ago. Windows Mobile 7 will be based on either Windows CE 6 or a later version of Windows CE judging by its anticipated mid-to-late 2009 release. Since the last major Windows CE release, two iPhones have come along and, according to the people watching today’s WWDC keynote, eclipsed every smartphone in existence (we’ll disregard the argument that the iPhone is not a suitable enterprise tool for now).

Since the moment news of the first iPhone broke two Januarys ago, companies such as Meizu and HTC have tried to revamp the Windows Mobile interface with their own code, though only HTC has actually managed to push anything to the market. A number of threads discussing the new HTC Touch Pro have come and gone, with many people as-yet-unaffected by Mr. Jobs’ Reality Distortion Field seriously weighing the unreleased Touch (less so with its Diamond sibling) against the new iPhone and another HTC project, the Sony Ericsson XPERIA X1.

The impact of the iPhone is already visible in the preparation of new user interfaces for both Windows Mobile and RIM’s Blackberry (the Bold UI). However, with the announcement that iPhone v2 will carry full Exchange support, the latest iPhone is also making an attempt to invade the enterprise smartphone realm, and third party innovations for smartphones in this department typically have a high FAIL rate in catching on, so it’s up to Microsoft to keep itself awake and running. HTC pulled a lucky rabbit from its proverbial top-hat, but HTC’s experience lies in what most people in the Orient prefer with their phones: glitz, glamour, and lots of overly pretty animated functions, menus, spinning icons, and other similar user interface clutterings enhancements which missed the Longhorn boat back in 2004.

This gets me to what I think Microsoft might be forced to do with Apple’s growling 2ft-tall-and-growing-fast presence in front of it.

Background Applications won’t go away. Even though Apple had a fun jab at how background applications eat battery power and performance, I personally don’t believe Microsoft will let background applications go the way of the dodo. Instead, Microsoft will likely make enhancements to how Windows Mobile manages background applications. This will save battery power (good!) while making it less likely that your phone will be infected with spyware (good!), while also preserving backwards compatibility (good, but not as enthusiastically good).

A revamped user interface will likely be issued with Windows Mobile 7. While this has already been discussed many times in the past, I personally think the new UI will be developed in tandem with Windows 7’s User Interface. We’ve seen Windows 7’s poorly executed touch demo at D6 (I’ll keep my 50 cents Steve, thank you), but I think that Microsoft will keep a similar but highly condensed touch-centric user experience for Windows Mobile 7 for two reasons:

1. The iPhone has already made touch look cool, and with companies such as HTC pulling off some of the most ingenious touch interfaces , touch and gestures won’t be going away.
2. Microsoft has a history of keeping things looking alike (and yet disjointedly different at the same time) for the sake of branding. Windows Mobile 6 had this mildly Vista-esque feel through the use of gradients and glossed elements. On the other hand, this is a phone. One of the problems some people have with the iPhone is that while the user interface is great, the time it takes to go from one place to another (despite the presence of the home button) can get a bit annoying with the animations and other UI tidbits in place. In consumer environments, a glitzy UI is great, but in snappy business environments when CEOs are jumping from cabs and limousines to business meetings in skyscrapers while trying to arrange that multi-million (or billion) dollar merger during the only 30 second time slot available in the elevator trip to the top floor, the last thing that is needed are animations which eat time.

With that in mind, Windows 7 might be less of a festival of motion than Windows Mobile 6.1 with HTC’s TouchFLO, with a new interface likely catering to both businessmen and consumers alike.

Accelerated Development might split priority between Windows 7 and Windows Mobile 7. Should the two systems share a similar user interface, seeing Microsoft split its resources down the middle for both Windows and Windows Mobile might not be the largest surprise. One of Microsoft’s most successful areas is within the corporate sector, and with the iPhone trying to barge in, Microsoft might be much more inclined than before to put more emphasis on Windows Mobile development. With connectivity becoming the ultimate focus for Windows 7, seeing a heavy emphasis on connectivity between Windows Mobile, 7 and Windows 7 might be less of a shock now than it might’ve been, say, three to six months ago. This doesn’t mean we’ll see Windows 7 launch in 2009, nor does it mean that Windows 7 will come before the second half of next year (but it might). All it means is that more teams might be devoted to Windows Mobile 7, with collaboration between both Windows and Windows Mobile development climbing much higher than ever before. This could also mean that a number of Microsoft’s Windows 7 “pillars” will carry over into Windows Mobile.

Mind you, all of this is my own mindless speculation. The iPhone is not a crystal ball, I can’t see into the future, and the phone in the ball is an HTC Touch Pro. If you have any other ideas as to which directions Microsoft might take with Windows Mobile, post! Comments are below, but before you post, here’s a dose of irony, courtesy of Paul Thurrott.

With Vista, Microsoft redesigned Windows Explorer a lot. One of the biggest changes was the removal of the customizable toolbar. Up to Windows XP, adding or removing the buttons that were displayed in Explorer was a simple chore.
With Vista, this customization ability is gone; the toolbar is replaced by a so-called green shaded “commandbar,” and none of it can be customized unless you are willing to take a dive into the registry.

In this post, I will show you a way to add custom buttons — like in the above image — to the commandbar by adding items to the registry. Unfortunately, not all buttons (e.g. New Folder) are possible via this way.

The registry key

We start by opening up regedit as administrator (start, type regedit and hit enter. Accept the UAC prompt if you have UAC enabled). Once inside regedit, we navigate to the following key:

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\explorer\FolderTypes

Under this key, you’ll see a list of numbers in the format of {de2b70ec-9bf7-4a93-bd3d-243f7881d492}. These numbers are CLSIDs and represent the special folders such as Documents, Music, Drives in Explorer.
Most of the CLSIDs can be figured out by clicking the registry key and looking at the CanonicalName. For example, {de2b70ec-9bf7-4a93-bd3d-243f7881d492} has its CanonicalName set to Directory.Contacts, so it is likely that these CLSID refers to the Contacts folder.

TaskNoItemsSelected

Under some of the CLSID registry keys, you’ll see another key named TaskNoItemsSelected. For example, {de2b70ec-9bf7-4a93-bd3d-243f7881d492} (the Contacts folder) has this subkey. If you further expand this key, you will see that it has numbered subkeys 0, 1, 2 and 3.
These subkeys actually contain a description of the buttons that are added to the commandbar when no item is selected in the Contacts folder.

Editing TaskNoItemsSelected

Before we can edit this registry key, you need to make sure you have the proper rights to do so. On a fresh install, only the installer can write or modify these registry keys.
If you plan on editing some of the button, take ownership of the FolderTypes registry key by right-clicking it and selecting Permissions. Next, click Advanced and go to the Owner tab. In here, you can select your own user or the Administrators group as the new owner. Before hitting OK, tick the bottom-most checkbox saying something along the lines of ‘Replace owner of the underlying objects’.
After doing this, you now have the proper rights to edit the FolderTypes.

We start by adding a new key under the {de2b70ec-9bf7-4a93-bd3d-243f7881d492}\TaskNoItemsSelected key. We name it 4, since 0 to 3 already exists.

The next thing we need to do is add another subkey under the 4 key, which needs to be a unique and long number (called a GUID). For generating GUIDs, we use the following tool: http://www.somacon.com/p113.php . Hit the Generate UUID/GUID button and copy the GUID to the clipboard. We got the {61C0D9CB-BB72-4013-8769-EC628B50C351} GUID from this tool.
Now we got a GUID, we add it under TaskNoItemsSelected\4 as a subkey, so we end up with the key:

\TasksNoItemsSelected\4\{61C0D9CB-BB72-4013-8769-EC628B50C351}

In this key, we add the following values in the right pane:

• (default), Character string, with a value of MyButton
• Icon, Expendable Character string, with a value of c:\windows\system32\calc.exe, 0
• InfoTip, Character string, with a value of My Custom Tooltip
• Title, Character string, with a value of My Custom Item

When done right, you’ll end up with:

These values let Explorer know how our button should look like. They are self-explanatory, except for Icon, which takes a string in the form of PathToExeOrDllFile, iconNumber. In our example, we tell Explorer to use the first Icon from the Calculator.

We now have told Explorer what our custom button looks like, but not what it should do. We do this by adding a the following subkeys to our custom-button key: shell\InvokeTask\command. In the command key, we change the (Default) value to the application we want to launch when the button is clicked. Let’s put in c:\windows\system32\calc.exe to launch calc.

If you did everything right, you ended up with the following key structure under FolderTypes:

Now, if you go into the Contacts folder, you will see a My Custom Item button, which, when clicked, will launch the Calculator.

Next time we will delve into the TasksItemsSelected list, which has some additional properties!