The Windows Blog

Developing for the Windows 7 Taskbar – Jump into Jump Lists – Part 3

Yochay Kiriaty — Thu, 02 Jul 2009 20:59:29 GMT

So far, you have seen how you can opt into the Windows 7 Taskbar Jump List experience by creating a Jump List for your application (in the Developing for the Windows 7 Taskbar – Jump into Jump Lists – Part 2 post.) You have also seen the Windows 7 default support for listing “Recent” or “Frequent” destinations as well as how to create your own custom categories. In this post, we will explore more of the Jump List features and discover how easy it is to add Tasks to your application's Jump List.

User tasks are customized tasks that get their own Tasks category. As a developer, you can set the title of the displayed task, the icon on the left and, more important, and the “application” that is launched once you activate this task. You can view user’s tasks as shortcuts to the functionality our applications can provide. As you might remember, user tasks are the verbs in our vocabulary; for example, Windows Media Player provides a “Resume last playlist” task and Sticky Notes provides a “New note” task.

A user task is usually an IShellLink object that launches any given application (your application or any other one you choose) with specific command line parameters. While you cannot categorize tasks, you can separate them using a special separator object. Here’s an example of a Jump List that uses a separator to split three tasks into a group of two plus an additional task:

So what does it take to add tasks to a Jump List? Well, not that much. Basically it is a single call to the AddUserTasks function in an interface that we are already familiar with, the ICustomDestinationList (ICustomDestinationList::AddUserTasks(IObjectArray) Method). Looking at the code, you will see a single line of code, hr = pcdl->AddUserTasks(poa);. However, as always, someone needs to create and build that poa, IObjectArray, and parameter and fill it with relevant information. Let’s review that process now.

We are going to create a collection of IShellLinks. This collection will be later cast to the required IObjectArray parameter. The following code is the beginning of that process.

IObjectCollection *poc;
HRESULT hr = CoCreateInstance(
D_EnumerableObjectCollection, NULL, CLSCTX_INPROC, IID_PPV_ARGS(&poc));
if (SUCCEEDED(hr))
{
    IShellLink * psl;
    hr = _CreateShellLink(L"/Task1", L"Task 1", &psl);
    if (SUCCEEDED(hr))
    {
        hr = poc->AddObject(psl);
        psl->Release();
    }
}

Here you can see that we used COM (again) and CoCreate and IObjectCollection, poc. Next, we call to a helper function called CreateShellLink that receives three parameters:

The first parameter is the command line argument to the task
The second parameter is the title that will be displayed
The last parameter is a pointer to IShellLink

The object is then filed according to the relevant information.

Last, we add the recently created IShellLink to the object collection. You may ask yourself where the parameter that provides the path to the executable that we plan to launch is. Well that is a good question. For simplicity, we have hard-coded that information as shown in the following code snippet:

if (SUCCEEDED(hr))
{
    hr = _CreateShellLink2(
            L"C:\\Users\\<my user>\\Documents\\new text file.txt", 
            L"NotePad", 
            &psl);

    if (SUCCEEDED(hr))
    {
        hr = poc->AddObject(psl);
        psl->Release();
    }
}

Here you can see we call to a hard-coded _CreateShellLink2 function. This receives a path to a text file as one of its parameters and, as you can see, we are launching Notepad.

Here is the code for the CreateShellLink2 function:

HRESULT _CreateShellLink2(
            PCWSTR pszArguments, PCWSTR pszTitle, 
            IShellLink **ppsl)
{
    IShellLink *psl;
    HRESULT hr = CoCreateInstance(
                    CLSID_ShellLink, 
                    NULL, 
                    CLSCTX_INPROC_SERVER, 
                    IID_PPV_ARGS(&psl));
    if (SUCCEEDED(hr))
    {
        hr = psl->SetPath(c_szNotePadExecPath);
            if (SUCCEEDED(hr))
            {
                hr = psl->SetArguments(pszArguments);
                if (SUCCEEDED(hr))
                {
                    // The title property is required on Jump List items 
                    // provided as an IShellLink instance. This value is used 
                    // as the display name in the Jump List.
                    IPropertyStore *pps;
                    hr = psl->QueryInterface(IID_PPV_ARGS(&pps));
                    if (SUCCEEDED(hr))
                    {
                        PROPVARIANT propvar;
                        hr = InitPropVariantFromString(pszTitle, &propvar);
                        if (SUCCEEDED(hr))
                        {
                            hr = pps->SetValue(PKEY_Title, propvar);
                            if (SUCCEEDED(hr))
                            {
                                hr = pps->Commit();
                                if (SUCCEEDED(hr))
                                {
                                    hr = psl->QueryInterface
                                            (IID_PPV_ARGS(ppsl));
                                }
                            }
                            PropVariantClear(&propvar);
                        }
                        pps->Release();
                    }
                }
            }
        else
        {
            hr = HRESULT_FROM_WIN32(GetLastError());
        }
        psl->Release();
    }
    return hr;
}

To start with, again we need to use COM and CoCreate to create an IShellLink COM object. A quick look at the SDK reveals that the IShellLink object has many functions. Here are few that we will use:

GetPath Gets the path and file name of a Shell link object, that is the path to the executable
GetShowCmd Gets the show command for a Shell link object, the executable name
SetArguments Sets the command-line arguments for a Shell link object
SetDescription Sets the description for a Shell link object; the description can be any application-defined string
SetIconLocation Sets the location (path and index) of the icon for a Shell link object SetPath Sets the path and file name of a Shell link object
SetWorkingDirectory Sets the name of the working directory for a Shell link object

As you can see, for each parameter we must get and set appropriate methods. There are additional parameters; take a look at the SDK - IShellLink if you want to learn more.

In the above example, we set the path to Notepad (by default in the Windows 7 installation, c:\windows\notepad.exe). We also passed a hard-coded (not a good practice) command line argument pointing to a text file in my private document folder (C:\Users\<my user>\Documents\new text file.txt.) The rest of the code sets the title property that is required on Jump List items.

We call the CreateShellLink2 and CreateShellLink a few more times to add all three shortcuts as shown in the above screen capture.

Now let’s add a separator.

To add a separator to our Task List, we need to create an IShellLink, and set the PKEY_AppUserModel_IsDestListSeparator property using the COM property variant as shown in the following code snippet:

// The Tasks category of Jump Lists supports separator items. 
// These are simply IShellLink instances that have the 
//  PKEY_AppUserModel_IsDestListSeparator property set to TRUE. 
// All other values are ignored when this property is set.
HRESULT _CreateSeparatorLink(IShellLink **ppsl)
{
    IPropertyStore *pps;
    HRESULT hr = CoCreateInstance(
                    CLSID_ShellLink, 
                    NULL, 
                    CLSCTX_INPROC_SERVER, 
                    IID_PPV_ARGS(&pps));
    if (SUCCEEDED(hr))
    {
        PROPVARIANT propvar;
        hr = InitPropVariantFromBoolean(TRUE, &propvar);
        if (SUCCEEDED(hr))
        {
            hr = pps->SetValue(PKEY_AppUserModel_IsDestListSeparator, propvar);
            if (SUCCEEDED(hr))
            {
                hr = pps->Commit();
                if (SUCCEEDED(hr))
                {
                    hr = pps->QueryInterface(IID_PPV_ARGS(ppsl));
                }
            }
            PropVariantClear(&propvar);
        }
        pps->Release();
    }
    return hr;
}

Here you can see that we used CoCreate to create an IShellLink object. Next, we set a PROPVARIANT, propvar, to true and set the IShellLink object PKEY_AppUserModel_IsDestListSeparator property to true. This will instruct the OS to render this IShellLink as a separator and not just as regular IShellLink.

OK, that was long. Now let’s look at the short version, using .NET. For that we are going to use the Windows API Code pack for the .NET Framework.

As we can expect from .NET, we get abstraction from most of the “COM code behind” that is required. The Microsoft.WindowsAPICodePack.Shell.Taskbar namespace includes a JumpListLink object that extends the ShellLink object and implements IJumpListTasks.

The JumpList class contains the UserTasks collection of IJumpListTasks to which you can simple add new JumpListLink objects as shown in the following code snippet:

// Path to Windows system folder
string systemFolder = 
        Environment.GetFolderPath(Environment.SpecialFolder.System);

jumpList.UserTasks.Add(new JumpListLink
{
    Title = "Open Notepad",
    Path = Path.Combine(systemFolder, "notepad.exe"),
    IconReference = new IconReference(
(systemFolder, "notepad.exe"), 0)
});

Using the C# 3.0 syntax, we initialize a new JumpListLink object and add it to the UserTasks collection. As you can see, the managed code JumpListLink has very similar properties to the native one (which makes perfect sense). We also added an icon to the Notepad shortcut to the above code, but didn't provide any command line parameters.

You want to add a separator? Well, that is also very easy: just add a JumpListSeperator object to the UserTasks collection.

jumpList.UserTasks.Add(new JumpListSeparator());

Please note that, as always, when working with the Windows Code pack API Taskbar, you have to call the “refresh” function in order to commit the changes, as we explained in the previous post.

Taskbar.JumpList.RefreshTaskbarList();

After the refresh, the Jump List looks as follows:

I’ve compiled a version of a native example from the Windows 7 SDK. You can get a copy of that code from here

You can download the Windows API Code Pack that includes the manage code example we used in this post.

This concludes our Jump List discussion. Our next Taskbar topic is Icon Overlay.

What’s new at Talking About Windows.com

Stephen L Rose — Thu, 02 Jul 2009 16:18:55 GMT

If you haven visited Talking About Windows.com in a while, you are missing a lot!

You missed Microsoft Engineers like Ian Burgess talking about the engineering design of DirectAccess and BitLocker and Mario Garzia discussing application compatibility and how Windows 7 works with legacy applications.

You can interact with IT pros like Darren Baker, the National Director of Infrastructure Solutions for Sogeti USA talk about how virtualization and imaging has made implementing Windows 7 in his organization easier.

Talking About Windows.com is your chance to hear what Microsoft Engineers and IT pros like you have to say and gives you a chance to interact with them.

Hear what they have to say and get heard. Join the conversation.

SCCManager 2007 Service Pack 2 Beta aka ConfigMgr07 SP2

Stephen L Rose — Thu, 02 Jul 2009 00:42:49 GMT

Today I am featuring guest Blogger Jeremy Chapman from the Windows Product Team. To see more of Jeremy, view our latest VRT on Application Compatibility. To learn more, click here. Below is his interview with Jeff Wettlaufer from the System Center Team.

I recently interviewed fellow product manager, long-time friend and fellow “automator” of operating system deployment tasks, Jeff Wettlaufer, from the System Center team. He explained the new features in the recently released System Center Configuration Manager 2007 Service Pack 2 Beta (let’s just call it “ConfigMgr07 SP2” for short), and how that will help with Windows 7 deployment and management.

Jeremy: What is ConfigMgr07 SP2 and where do people get it?
Jeff: Thanks for having me and thanks for saying configmgr and not sccm for once… SP2 adds support for new operating systems – Windows 7 and Server 2008 R2 and Windows Vista SP2 – along with exciting enhancements around Intel AMT integration. If you have the Intel vPro hardware, there are many things we can do. Out of Box Wired/Wireless Management: Wireless Profile Management, End Point Access Control: 802.1x support, Access Monitor: Audit Log, Remote Power Management: Power State Configuration. You were at Microsoft Management Summit in May and already saw this, but we demoed waking Windows XP PCs up wirelessly and kicking off the deployment to Windows 7 using USMT and hard-link migration. Those machines were mid range Dell latitude laptops, and we migrated to Windows 7 with 4GB user data and apps in 18 minutes.

Jeremy: I saw that, it was amazing. There is a video of that on Microsoft PressPass. And I thought I was fast with 23-minute migrations from Windows XP on my computers. Let’s take a step back for a second. From the 10,000 ft level, how does ConfigMgr07 help with client management?

Jeff: A lot of people probably know about how ConfigMgr can help with their inventory, software update (patch) management, and application distribution - but you may not be aware of things like the ability to manage PCs over the Internet, in the ‘serverless’ branch, at home, on the road and wherever people work these days. In addition, ConfigMgr can now deploy virtual applications in the same way as SMS and ConfigMgr have always delivered traditional physical formats. We can stream apps to desktops, or deliver the apps locally in what’s called download and execute, so even mobile laptop users can use virtual apps. There is a lot there and I’d encourage everyone to check out http://technet.microsoft.com/en-us/configmgr/default.aspx

Jeremy: Explain Internet-based client management.

Jeff: A lot of people say that mobile workforce management is a key challenge they face today on the client. Laptops are outselling desktops and people are taking these on the road, home or otherwise not connecting to the corporate network very often. So with ConfigMgr, we can manage ConfigMgr clients when they are not connected to your company network but have a standard Internet connections. This feature has a number of advantages, including the reduced costs of not having to run virtual private networks (VPNs) and being able to deploy software updates to remote users while they are traveling or at home.

Jeremy: Explain the new client hardware compatibility reports in HW inventory.

Jeff: We’ve updated the hardware compatibility reports in ConfigMgr to include the minimum bars for Windows 7 hardware compatibility, so you can see which machines in your environment are capable of running Windows 7 in a single view. We did this for Vista, and we found it really helped organizations understand where they were at the hardware level. We are taking that work forward to also help customers understand from their existing inventory of managed systems, which ones meet the minimum requirements before they start for Windows 7. As well as helping understand the hardware side of readiness, we also are providing support for applications. In the past we have provided support for the Application Compatibility Toolkit through a connector, that brings the app knowledge right into the Admin console. As ACT moves to version 6 for Windows 7, we will update the connector to support that effort. The ACT data is a real hidden gem, in 1 view you can see your apps – and organize your testing to compare it in that 1 view to the vendor, the community, and even Microsoft. This information can really help make the right decisions moving forward, and ConfigMgr can help migrate apps by supporting Application virtualization where needed.

Jeremy: How about the operating system deployment support.

Jeff: With any operating system deployment, you have to migrate user files off the old system, lay down a new OS, configure it with updates, packages and apps, then restore the user files and settings you migrated off in the first step. ConfigMgr can automate the whole process and do it without you having to visit the targeted PCs. I know you’ve got a lot of videos walking through the Lite Touch Installation process on the web, but ConfigMgr can even target the PCs for installation and kick off the process for you. Along the way we encrypt your user state, passwords and product keys, so it is more automated and enterprise-class. ConfigMgr has built on the great work in deployment technology from the Windows gang, by embracing and integrating the tools usage like WinPE, USMT, BitLocker and more. Our Task Sequencer helps to truly separate the hardware from the OS and application layers, by using the boot.wim and install.wim formats from Windows, and then providing a console UI experience to chain user data migration, applications and other settings.

Jeremy: Are all the Windows 7 deployment enhancements like the image servicing in DISM (Deployment Image Servicing and Management), hard-link migration, and Multicast included in the ConfigMgr SP2’s OS deployment?

Jeff: Like you saw at MMS, we do support USMT in ConfigMgr07, including hard-link migration. The Microsoft Deployment Toolkit 2010 Beta 2 extensions for SP2 enable hard-link migration without additional customization, or you can call the User State Migration Tool in a custom task to use the hard-link commands. Multicast is also supported and since we use the Windows 7 deployment tools, dism.exe is leveraged as well.

Jeremy: When can we expect RTM release of SP2?

Jeff: We recently made the Beta available and the final version should be ready within 90 days of Windows 7 RTM. Everything depends on the customer feedback we get from the Beta though – quality is the priority.

Jeremy: Thanks Jeff. If you have ConfigMgr and want try to SP2 Beta, visit connect.microsoft.com, join the System Center Configuration Manager 2007 Service Pack 2 Connection and download SP2.

Remaining Windows Vista SP2 Languages Released to Windows Update

Brandon LeBlanc — Wed, 01 Jul 2009 04:34:10 GMT

Back on May 26th, we announced Windows Vista SP2 and Windows Server 2008 SP2 hit the RTW milestone. The first wave of languages (English, German, French, Spanish, and Japanese) was made available on Windows Update at that time. Today, we are releasing the remaining languages for Windows Vista and Windows Server 2008 SP2 to Windows Update.

For more information, including languages, on Windows Vista and Windows Server 2008 SP2 click here.

If you have Windows Update configured to download updates automatically, Windows Update will notify you when Windows Vista SP2 and Windows Server 2008 SP2 is ready to be installed.

The Springboard Application Compatibility VRT rebroadcast is live!

Stephen L Rose — Wed, 01 Jul 2009 01:04:00 GMT

Last week we posted the promo teaser here on the Springboard Blog for the Virtual Roundtable on Application Compatibility. As of today, the rebroadcast is live and ready for you to view.

If you missed the live broadcast, here’s your chance to hear Aaron Margosis, Paul Schnell; Darren Baker (also watch for Darren’s interview on TalkingAboutWindows next week), Greg Lambert Michael Sciacqua, Gov Maharaj, Celine Allee, Jeremy Chapman, and of course Mark Russinovich discuss the issues in getting your Windows XP and Windows Vista applications to work with Windows 7 quickly and effectively. From ACT 5.5 and Shims to discussions on key resources and tools, this VRT is a must see for those IT pros looking to make the jump to Windows 7.

To view the complete VRT, click here.

Also, here are some of our previous VRTs you can view as well.

Internet Explorer 8 helps you save time with Accelerators

Brandon LeBlanc — Tue, 30 Jun 2009 18:47:46 GMT

There’s been a great deal of more talk lately about browser performance. You may have seen some previous discussion about page load performance as you saw here in a video and whitepaper in March. Page load ensures that you get to where you want to go quickly. But page load time differences actually measure about the length it takes for a person to blink their eye once, making a win for any browser pretty inconsequential as far as time savings go.

However, Internet Explorer 8 today offers a feature that saves you time and clicks and lets you get things done more quickly: Accelerators. Accelerators optimize the browser experience by removing repetitive, time consuming actions and give people easy access to the online services they use most. You can discover new Accelerators for Internet Explorer 8 at the Internet Explorer 8 Add-ons Gallery.

With all the talk about performance, we wanted to see what features like Accelerators really meant for time savings when people use the web, so we created another video looking at common tasks people actually do in four browsers: Safari 4.0, Chrome 2.0 beta, Firefox 3.5 beta 99 and Internet Explorer 8. Please note, all tests were performed using the default installation settings for each browser. No additional add-ons or extensions were added.

Here is a video that shows off how Accelerators in Internet Explorer 8 make your browsing experience quicker and easier:

Accelerators in IE8 Help Save Time!

Windows 7 Keyboard Shortcuts

Stephen L Rose — Mon, 29 Jun 2009 21:18:17 GMT

I love keyboard shortcuts. Using a combination of two or more keys that, when pressed, can be used to perform a task that would typically require a mouse or other pointing device saves me time and effort both in Windows and other programs.

Here are some of my favorite Windows 7 shortcuts that you may not be familiar with that are great time savers. For a complete list of all shortcuts, check out this page here.

Windows logo key +T	Cycle through programs on the taskbar
Windows logo key +Spacebar	Preview the desktop
Windows logo key +X	Open Windows Mobility Center
Windows logo key +P	Choose a presentation display mode
Shift+Windows logo key +number	Start a new instance of the program pinned to the taskbar in the position indicated by the number
Alt+Windows logo key +number	Open the Jump List for the program pinned to the taskbar in the position indicated by the number
Ctrl+Windows logo key +number	Switch to the last active window of the program pinned to the taskbar in the position indicated by the number

Do you have a favorite that you can’t do without? Share it with us in the comments area.

Important Update Regarding Windows Live Movie Maker Beta

Brandon LeBlanc — Mon, 29 Jun 2009 17:14:10 GMT

Starting July 1st, 2009, when you launch Windows Live Movie Maker Beta you will be prompted to implement a software update which will extend the beta. You can download the software update here to continue to use the software without any interruption. If you choose not to install the software update, you will be unable to continue to use the Windows Live Movie Maker Beta.

The folks on the Windows Live Movie Maker Team are hard at work on “V1” which should be out sometime this year. For more information on the future of Windows Live Movie Maker, see this excellent blog post by Lead Program Manager Mike Torres from the Windows Live Team Blog.

I’m pretty excited for what they have in store for Windows Live Movie Maker!

Developing for the Windows 7 Taskbar – Jump into Jump Lists – Part 2

Yochay Kiriaty — Fri, 26 Jun 2009 01:19:07 GMT

This is the second post about the Taskbar Jump List in a series of Windows 7 Taskbar posts. In the previous post, Developing for the Windows 7 Taskbar – Jump into Jump Lists – Part 1, we introduced the elements that comprise the Taskbar Jump Lists: the destination (also referred to as “nouns”) and the Tasks (also referred to as “verbs”). As developer, you have a large amount of control over these elements. In this post, we walk through the different APIs that you can use when programming the Taskbar Jump Lists.

Before we begin, there is one very important thing you need to know. “Items” in the Recent category, or in any other category (any destination), must have a registered file handler for your application in the registry. This doesn’t mean that your application must be the default handler for that specific file type, it just means that your application must have a registered handler for all the files that you want to be visible in the Jump List. Therefore, “items” can only be files. Remember, by clicking on one of the items in the Jump List, the OS executes the command associated with that file as it relates to your application. When you register a file handler, you also specify the application that handles this file, and you define how to pass the input parameter for the application. Another important note to remember: All the items (files) have to be local – that is, on the local hard drive, and accessible to your application. Therefore, we can say that each and every item among the Jump List destinations is an accessible, local file, with a file handler registered to your application.

As we explain in the following section, once you have registered your file handlers, the OS actually helps you keep track of all your files. We will cover file handler registration in the next post.

Step 1 – Use the Out-of-the-Box Windows Experience and Default Behavior

By default, a Jump List contains a Recent category that is populated automatically for file-based applications through the SHAddToRecentDocs function. This function adds the used “item” (file) to the Shell's list of recently used documents. In addition to updating its list of recent documents, the Shell adds a shortcut to the user's Recent directory. The Windows 7 Taskbar uses that list and the Recent directory to populate the list of recent items in the Jump Lists.

Windows can also do the work for you if your application's file type is registered. Anytime you double click on a file type with a registered handler, before Windows launches your application it automatically calls SHAddToRecentDocs on your application's behalf. This inserts the item in the Windows Recent list and eventually into the Jump List Recent Category. The same automatic behavior occurs when using the Windows Common File Dialog (CFD) to open files through our applications. Therefore, this is another good reason to use the CFD introduced in the Windows Vista timeframe, and it also plays a vital role regarding libraries, as we explained in the Light Up with Windows 7 Libraries post.

Both of the above cases exploit default Windows behavior in cases where you have a registered handler and an Application ID by which the files are associated with Recent and Frequent lists. In both cases, Windows automatically inserts the items into the Jump Lists unless you specifically remove this functionality by using the COM API. Obviously, users also have the option to remove any items from their Jump Lists. By explicitly removing an item from the Jump List, you insert it into the Removed Items List, which we will discuss below.

Step 2 – Create Your Own Category

If the default Recent or Frequent categories do not meet your application's needs, it is time to create your own custom category. In order to do so, you need to use the ICustomDestinationList interface to create a custom Destination List.

The ICustomDestinationList exposes methods that allow an application to provide a custom Jump List, including destinations and tasks, for display in the Taskbar. Here are the methods that we are using for the example below:

AppendCategory Defines a custom category and the destinations that it contains for inclusion in a custom Jump List
AppendKnownCategory Specifies that the Frequent or Recent category should be included in the Jump List
BeginList Initiates a building session for a custom Jump List
CommitList Declares that the Jump List initiated by a call to BeginList is complete and ready for display

The following code snippet shows how to create a new custom list called “Custom Lists” and appends a few items to it:

void CreateJumpList()
{    
    ICustomDestinationList *pcdl;
    HRESULT hr = CoCreateInstance(
                    CLSID_DestinationList, 
                    NULL, 
                    CLSCTX_INPROC_SERVER, 
                    IID_PPV_ARGS(&pcdl));
    if (SUCCEEDED(hr))
    {
        //important to setup App Id for the Jump List
        hr = pcdl->SetAppID(c_szAppID);
        if (SUCCEEDED(hr))
        {
            UINT uMaxSlots;
            IObjectArray *poaRemoved;
            hr = pcdl->BeginList(
                            &uMaxSlots, 
                            IID_PPV_ARGS(&poaRemoved));
            if (SUCCEEDED(hr))
            {
                hr = _AddCategoryToList(pcdl, poaRemoved);
                if (SUCCEEDED(hr))
                {
                    pcdl->CommitList();
                }
                poaRemoved->Release();
            }
        }
    }
}

Here you see that we started with a standard COM initialization call. We call CoCreateInstance to initialize the ICustomDestinationList object (this is the joy of working with COM….). Next, we set the Application ID in order to allow you to start populating items to the list.

The BeginList function initiated the build session for the custom Jump List. This function returns the maximum number of items that can fit in a given Jump List; the default is 10. You may note the Remove item parameter, IObjectArray *poaRemoved, that the BeginList() returned as an out parameter. This holds any specific items that the user removed from the Jump List in his current session. We discuss the Removed Items List later in this post.

Next we called a helper function, _AddCategoryToList(), to do the actual work of adding items into the custom category.

// This is the helper function that actually appends the items to a collection 
// object HRESULT _AddCategoryToList(ICustomDestinationList *pcdl, 
// IObjectArray *poaRemoved)
{
    IObjectCollection *poc;
    HRESULT hr = CoCreateInstance
                    (CLSID_EnumerableObjectCollection, 
                    NULL, 
                    CLSCTX_INPROC_SERVER, 
                    IID_PPV_ARGS(&poc));
    if (SUCCEEDED(hr))
    {
        for (UINT i = 0; i < ARRAYSIZE(c_rgpszFiles); i++)
        {
            IShellItem *psi;
            if (SUCCEEDED(SHCreateItemInKnownFolder(
                                FOLDERID_Documents, 
                                KF_FLAG_DEFAULT, 
                                c_rgpszFiles[i], 
                                IID_PPV_ARGS(&psi)))
                )
            {
                if(!_IsItemInArray(psi, poaRemoved))
                {
                    poc->AddObject(psi);
                }

                psi->Release();
            }
        }

        IObjectArray *poa;
        hr = poc->QueryInterface(IID_PPV_ARGS(&poa));
        if (SUCCEEDED(hr))
        {
            pcdl->AppendCategory(L"Custom category", poa);
            poa->Release();
        }
        poc->Release();
    }
    return hr;
}

Another new interface that we use is the IObjectCollection that represents a collection of objects that support IUnknown. To this collection we add IShellItems. Each item (file) that we added to the Jump List is of an IShellItem type. In the above code, we created a Shell item object for a single file that exists inside a known folder, Documents. However, before we actually added the new item to the collection, we needed to determine if the user had already removed it. If the user explicitly removed an item from the Jump List, that item will be in the Removed Items List (again associated with the AppID), and, as developers, we need to respect the user's requests and avoid adding that item to the Jump List. We already have the list of removed items, IObjectArray *poaRemoved, that we got when we called the BeginList(…) function when we initiated creation of a new list.

At this stage, you have a collection of Shell items that the user expects to see in the Jump List. Next we added that collection to the ICustomDestinationList object and created a new category named “Custom category”, pcdl->AppendCategory (L"Custom category", poa);.

So now you have successfully created a new category in the Taskbar called “Custom category” and populated it with four items. However, our work is not done yet. The final step in the CreateJumpList function is to call CommitList() to end the “transaction” that began with calling BeginList(). Only after our call to CommitList() are the new category and new items displayed. Calling CommitList() causes the stored list of removed items to be cleared and a new Removed Items List to begin. The ICustomDestinationList interface provides a "transactional base" API.

In order to ensure a positive end user experience, make sure that a safe copy of the new repopulated list is complete and ready for use, and that the only operation the Taskbar must perform is to switch the pointer to the new list. The end result looks like:

Using the Windows API Code Pack we can write the same application using managed code.

Once we are sure that we are using the same AppID with all the Taskbar elements, we can create an instance of the Taskbar Jump List for the button that we are working on, as shown in the following code snippet. This code snippet is part of the CTOR of the main application window:

// Set the application specific id
Taskbar.AppId = appId;
// Retrieve the taskbar jump list
jumpList = Taskbar.JumpList;
category1 = new CustomCategory("Custom Category 1");
category2 = new CustomCategory("Custom Category 2");
// Add custom categories
jumpList.CustomCategories.Add(category1);
jumpList.CustomCategories.Add(category2);
// Default values for jump lists
comboBoxKnownCategoryType.SelectedItem = "Recent";

Here you can see that we set the AppID using the AppId property and created an instance of the Taskbar Jump List using the Taskbar.JumpList static property. We also create two categories, named Custom Category 1 and Custom Category 2. Next, we add these categories to the Jump List custom categories container. Last we set the Known category of this Taskbar Jump List to Recent. This will automatically get populated as described above.

After we set up the custom category, it is time to put some content in it. To do so, we just need to call the Add function to add a JumpListItem to the JumpListCollection. The JumpListItemCollection is a generic collection (of<IJumpListItem>) holding IJumpListItem items. IJumpListItem item is basically some sort of wrapper for the native IShellItem.

// Specify path for shell item
string path = String.Format("{0}\\test{1}.txt",
                            executableFolder,
                            category1.JumpListItems.Count);
// Add shell item to custom category
category1.JumpListItems.Add(new JumpListItem(path));

First, we need to construct a path to the file we want to include in the Jump List. Please remember that we can call the Add function only if this file is local and accessible to your user. The above code (along with a few other methods that we will describe in future posts), results in a Taskbar dialog that looks like:

Finally, we need to call the Taskbar.JumpList.RefreshTaskbarList() Function. As with the native Jump List implementation, we need to “commit” the changes made to the Jump List. A closer look at this Refresh function (you have access to it in the Code Pack API) shows a call to the AppendCustomCategories function that appends any custom categories to the Taskbar button Jump List. Within this function, you can find a managed code implementation of the native code shown above. It includes a call to the AppendCateogry function that is a wrapper for the native AppendCategory function above.

IObjectCollection categoryContent =
    (IObjectCollection)new CEnumerableObjectCollection();

// Add each link's shell representation to the object array
foreach (IJumpListItem link in category.JumpListItems)
    categoryContent.AddObject(link.GetShellRepresentation());

// Add current category to destination list
HRESULT hr = customDestinationList.AppendCategory(
    category.Name,
    (IObjectArray)categoryContent);

As you can see, it is easy to opt into the Windows 7 Taskbar functionality. Windows automatically performs most of the work for you and, if you do need to create your own category, that is also very easy.

In the next post we will describe how you can add new Tasks to the Jump List and how to register a file handler.

Announcing the Windows 7 Upgrade Option Program & Windows 7 Pricing – Bring on GA!

Brandon LeBlanc — Thu, 25 Jun 2009 13:00:28 GMT

Today we have some news to share around Windows 7 including answering what may be some of the “hottest” questions people have as we head toward General Availability (GA) on October 22nd.

I had the opportunity to sit down with Brad Brooks, Corporate VP for Windows Consumer Marketing, to talk about today’s announcements.

Announcing the Windows 7 Upgrade Option Program & Windows 7 Pricing

Special thanks to Brad for taking the time to talk through these details with me. You’ll find a transcript of the video here.

As Brad discussed in the video, today we’re announcing details for the Windows 7 Upgrade Option Program, pricing, and a special pre-order offer for select markets.

But first, I want to talk a little bit more about GA and the worldwide availability of Windows 7. We’ve really focused a lot of our efforts on getting the product out to as many people around the world as quickly as possible. OEMs will start shipping PCs with Windows 7 in all language versions beginning on GA, October 22nd.

And for our retail software, we’ve made significant strides in terms of timing. Gone are the days when it could take months for all language versions to be available. In fact – we’ve narrowed the gap to just over ONE week!

On October 22nd, Windows 7 will be available in the following 14 languages: English, Spanish, Japanese, German, French, Italian, Dutch, Russian, Polish, Brazilian Portuguese, Korean, Simplified Chinese, Traditional Chinese and Chinese (Hong Kong).

Then on October 31st, the remaining 21 languages will become available: Turkish, Czech, Portuguese, Hungarian, Swedish, Danish, Norwegian, Finnish, Greek, Ukrainian, Romanian, Arabic, Lithuanian, Bulgarian, Estonian, Slovenian, Hebrew, Thai, Croatian, Serbian Latin, and Latvian.

Windows 7 truly is a global release and I’m excited to be able to tell my international friends that when I say Windows 7 will be available for the holidays – I mean everywhere in the world.

But, you don’t have to wait until GA to get a new Windows PC. In fact, we know many people need that new PC sooner – for back to school specifically. And we have the answer for people who need a new PC now but still want to get Windows 7 and that’s the Windows 7 Upgrade Option Program, which kicks off tomorrow, June 26th! Anyone who buys a PC from a participating OEM or retailer with Windows Vista Home Premium, Business or Ultimate on it will all receive an upgrade to the corresponding version of Windows 7 at little or no cost to customers. The Windows 7 Upgrade Option Program will be available until January 31st, 2010 – and is global! For more information on taking advantage of the Windows 7 Upgrade Option Program, visit www.windows.com/upgradeoffer.

Another one of the most common questions I get is: how much will Windows 7 cost? Well, today we’re sharing these details.

For Windows 7, we are reducing the price on our most popular retail product for customers, the Home Premium Upgrade, by approximately 10% (depending on the market). In the U.S., this means a customer buying Windows 7 Home Premium upgrade will pay only $119.99 instead of the $129.99 being charged today for its predecessor.

Overall, customers will be paying less and getting more with Windows 7. This includes fun new features such as HomeGroup, Device Stage, Aero Shake, Snap, Peek, Jump Lists and our completely redesigned Windows Taskbar (one of my favorite new features in Windows 7 today). These new features make your PC simpler and much easier to use.

So here’s the low-down on pricing for Windows 7. The estimated retail prices for upgrade packaged retail product of Windows 7 in the U.S. are:

Windows 7 Home Premium (Upgrade): $119.99
Windows 7 Professional (Upgrade): $199.99
Windows 7 Ultimate (Upgrade): $219.99

And the estimated retail prices for full packaged retail product of Windows 7 in the U.S. are:

Windows 7 Home Premium (Full): $199.99
Windows 7 Professional (Full): $299.99
Windows 7 Ultimate (Full): $319.99

This means that Windows 7 Home Premium full retail product is $40.00 less than Windows Vista Home Premium today.

As Brad describes in the video, for Europe, we will not have a separate upgrade SKU for the packaged retail product versions of Windows 7 at GA. But we will be offering upgrade pricing on our full licenses to make sure that European customers who want to upgrade have the pricing options available in the rest of the world.

Finally, as a way of saying thank you to our loyal Windows customers, we are excited to introduce a special time limited offer! We will offer people in select markets the opportunity to pre-order Windows 7 at a more than 50% discount. In the US, this will mean you can pre-order Windows 7 Home Premium for USD $49.99 or Windows 7 Professional for USD $99.99. You can take advantage of this special offer online via select retail partners such as Best Buy or Amazon, or the online Microsoft Store (in participating markets).

This program begins tomorrow in the U.S., Canada and Japan. The offer ends July 11th in the U.S. and Canada and on July 5th for Japan or while supplies last. Customers in the UK, France and Germany, can pre-order their copy of Windows 7 starting July 15th and will run until August 14th (or supplies last) to ensure folks don’t miss out on this. Act fast if you want to be the first in line to get Windows 7 at this screaming deal! Note: The special low pre-order price will vary per country.

For more information on this special pre-order offer, click here.

I am really excited to be sharing these Windows 7 announcements with you today. Because of the great feedback we received from you, we are confident we are poised to deliver a great product this fall!

Check out the New Windows 7 Packaging

Brandon LeBlanc — Wed, 24 Jun 2009 01:22:24 GMT

Simple, Clean and Easy To Open…

We approached the packaging for Windows 7 the same way we approached the product – by listening to what our customers told us they wanted: make it a simple clean design, easy to open, and reduce waste.

Simple Design

Customers told us they liked the big bold Windows logo and how it clearly communicates that it’s Windows 7. They like larger typefaces to make it easy to read. They also like the background colors for each edition that make it easier to differentiate between Windows 7 Home Premium all the way to Windows 7 Ultimate. In their own words, the “clean” design gives off a “fresh” feel.

Make It Easy To Open

We’ve reduced the number of elements in the package down to three: the plastic case, the paper sleeve, and a simple Getting Started Guide. The plastic case opens easily like a standard DVD case and it will have a single easy-to-remove seal at the top - and that’s it!

Reduce Waste

The plastic case protecting the Windows 7 disk is lighter and is recyclable. The packaging itself has a 37% weight reduction and the econometrics score has improved by 50% over it’s predecessor.

Essentially, the packaging is what customers told us they were most interested in picking up to learn more about Windows 7. We hope you do the same.

Look for the new Windows 7 packaging to hit this fall!

Lenovo Announces New T-Series ThinkPad Laptop – The T400s

Brandon LeBlanc — Tue, 23 Jun 2009 21:14:09 GMT

Lenovo announced today a new T-Series ThinkPad Laptop called the T400s. Lenovo’s T-Series laptops cater to business customers looking for a powerful and thin laptop. Lenovo put a lot of effort in designing this laptop to be light, durable, robust, and powerful – key elements to a great business laptop for the mobile worker. I’ve had the chance to play with a T400s here in my office for the last few days and it has been a great experience so far.

The T400s will ship with the following specs:

Choices of Intel 2.53 GHz Core2Duo processors and graphics
Choices of up to 128GB SSD or 250GB hard drive storage
9.5 mm slim DVD burner or Blu-Ray player
Ethernet (Gigabit) & WiFi
Optional WiMAX, WWAN, Bluetooth and Ultra-wideband Connectivity
34mm Express Card slot or 5-in-1 multimedia card reader
Almost 6 hours of battery life
Display Port and VGA connectors (Supports 2 External Monitors!)
Energy Star 5.0 Compliant
2 Built-in USB Ports
1 Built-in eSATA/USB Combo Port (Total of 3 USB Ports)
Fingerprint Reader
TPM 1.2

As you can see, with these specs the T400s is quite powerful. It also can come jam-packed with network connectivity options (including support for Mobile Broadband) helping keep you connected no matter where you go. Because security is super important to the Mobile Worker – the T400s comes with a Fingerprint Reader and TPM 1.2. With TPM 1.2, BitLocker can be used in both Windows Vista and Windows 7 to secure the laptop. You also get your choice of storage. My T400s had a 250GB hard drive.

The design of the T400s is pretty slick. The T400s uses Lenovo’s “Top Cover Roll Cage”, which they first introduced with the X300, in the construction of its frame. This roll cage is made out of reinforced monocoque carbon fiber which is the same stuff they use on airplanes and super-fast cars. This keeps the T400s pretty light. It weighs in at just under 4lbs (with a 6 cell battery) which is about 20% less than its T400 predecessor. A non-SSD hard drive may also add some weight to the laptop as well as they tend to be a little bit heavier. But Lenovo gives you the choice to choose (as mentioned above).

This is a pretty thin laptop, measuring in at 0.83 inches (yes, I measured!). Part of the ability to keep this laptop so thin is that Lenovo uses a very thin 14.1 inch LED screen.

For the T400s, Lenovo tweaked the keyboard a bit. The keys are much closer to each other – likely to prevent gunk from getting underneath. The Delete and ESC keys are also larger.

The touchpad is now flush with the palm rest and is textured to help people feel its location.

I also discovered that the T400s has an “always on” USB port in the back. This means that if the system is in sleep/standby or hibernate mode you can still plugin devices like MP3 players or mobile phones and have them charge off the laptop’s battery.

Another very interesting aspect of this laptop is how Lenovo optimized it for VoIP. Many businesses are utilizing VoIP for their communications. This laptop can essentially serve as your communication hub when you’re out-and-about. Lenovo added a new toggle switch at the top of the keyboard so that you can easily increase and decrease your system volume – putting the user in more control of their audio. I’m told this will become a standard for all Lenovo laptops going forward. The speaker volume has been amped up to be more than 2x greater than audio levels see on the T400. And the speakers themselves have been moved to the sides instead of on the palm rest area seen on the X300 series laptops.

Lenovo put 2 digital microphones in for better recording. The dual microphones are expected to cut down the amount of ambient noise picked up during your VoIP calls and improve clarity with sound. And of course you can have audio without video. The T400s comes with built in 2.0 megapixel webcam that can shoot video up to 30fps. The webcam also has “Lower Light Capture Capability” to capture decent video is very low-lit conditions.

Lenovo puts Windows Vista Business or Windows Vista Ultimate on their business laptops. The T400s I have came with Windows Vista Business.

However I decided to put Windows 7 (the Windows 7 RC) on it. Instead of upgrading from Windows Vista, I did a clean install. Windows 7 picked up most of the drivers with updates to many of them available for me on Windows Update. I had everything up and running very quickly.

With Windows 7 and the T400s, I am able to secure the laptop with a variety of features from Windows 7. Windows 7 has BitLocker (which we introduced with Windows Vista). Using TPM, I was able to encrypt the hard drive of the laptop to ensure if the laptop ever gets lost so that no one can get the data off the hard drive.

Windows 7 has a new biometric framework and in combination with UPEK’s biometric software – I was able to quickly enroll fingerprints for a further enhanced security. UPEK takes advantage of Windows 7’s biometric enhancements. This process was incredibly easy. As mentioned above, the T400s can come with built in Mobile Broadband. Windows 7 brings enhancements that take advantage of Mobile Broadband making it easy to connect and stay connected.

I had fun playing with this laptop. Special thanks to Lenovo for the opportunity!

The Lenovo ThinkPad T400s will become available at www.lenovo.com starting at $1,599.

Sheraton to Deploy Windows 7 Across Link@Sheraton Locations

Brandon LeBlanc — Tue, 23 Jun 2009 19:03:39 GMT

Today at HITEC (Hospitality Industry Technology Exposition and Conference) in Anaheim, CA, Sheraton Hotel & Resorts announced their plans to roll-out Windows 7 across their “Link@Sheraton” locations. I was able to chat with Mark McBeth who is the Vice President of IT for Starwood Hotels & Resorts (the parent company for Sheraton) to get some more details and insight into their plans:

Brandon LeBlanc: So tell me about the Link@Sheraton and your Windows 7 plans.

Mark McBeth: The Link@Sheraton is a social area in the lobbies of some of our Sheraton hotels that includes computers and technology resources for our guests. We’re working closely with Microsoft and will have Windows 7 available on the Link@Sheraton machines in select Sheraton locations later this summer – that’s before Windows 7 is even publicly available. What’s great about this arrangement is that our customers will be able to experience Windows 7, get a feel for some of the new features, and experiment with some of the applications we’ve developed in cooperation with Microsoft specifically for Link@Sheraton – all while being connected with the latest technologies.

Brandon LeBlanc: How is this deployment impacting your IT Department on the back-end?

Mark McBeth: It’s allowing us to develop our knowledge base on Windows 7. We support 480 hotels across North America and the deployment at the Link@Sheraton locations is serving as our testing grounds for a broader deployment across our national infrastructure. So it’s serving two purposes: customer satisfaction for our hotel guests, and hands-on experience with the OS for our IT Pros.

Brandon LeBlanc: What’s the general feedback you’ve received from your IT Pros on Windows 7 thus far?

Mark McBeth: From an IT perspective, we’ve received positive feedback on the performance and stability. For us, those are the very first things we look for in an OS for Sheraton. Stemming from the encouraging results we saw with our initial tests running Windows 7 on the Link@Sheraton machines, we expanded our current deployment to some of our production machines. We have about 40-50 machines at this point and once the general release comes later this fall, we plan to make Windows 7 our standard OS and begin to refresh our entire business operations environment.

Brandon LeBlanc: What’s the best thing about the Link@Sheraton and Windows 7?

Mark McBeth: It's a competitive differentiator -- we're using the latest technology to help our customers get their work done or bring them closer to their families when they're traveling. The Link allows them to do this in the lobby area instead of in some far away corner like in many other hotels. Plus, Windows 7 just works the way you want. It makes the user experience simpler, faster, easier and more fun - some of the computers in our lobbies will even have touch screen capabilities available for our customers to try.

Brandon LeBlanc: Thanks for chatting with me, Mark – I look forward to hearing more about Sheraton’s deployment down the line.

Mark McBeth: Thanks, Brandon.

For more information on Windows 7 being deployed across select Link@Sheraton sites, check out the PressPass feature here.

Windows 7 Release Candidate downloads will end August 15th

Stephen L Rose — Tue, 23 Jun 2009 16:39:00 GMT

Still on the Windows 7 Beta,? You need to move to the RC and fast. Starting July 1st, the Beta will start to reboot every 2 hrs and expire Aug 1st.

Want to download the RC? The RC download program closes August 15. After that, you won’t be able to get the download, but you can still install the RC and get a key if you need one. (To get a key, just go to the Downloads page and follow the instructions.)

If you’re using the Windows 7 Release Candidate, we hope you like what you see. Let us know - go to http://input.microsoft.com and tell us what you think. You’ll be able to give feedback on various aspects of the operating system.

Application Compatibility Roundtable Promo

Stephen L Rose — Tue, 23 Jun 2009 06:00:52 GMT

Our latest Virtual Roundtable on Application Compatibility was another great success. Thank you to all our viewers who tuned in live to watch it last week.

Missed it? Well, here is a promo video of some of the highlights. Watch for details later this week here on where to view the full program.

<br/><a href="http://video.msn.com/video.aspx?vid=7372d3d7-4c99-4561-9591-7fd338650d58" target="_new" title="VRT Promo">Video: VRT Promo</a>

You’ve angered the great Master Russinovich!

Stephen L Rose — Tue, 23 Jun 2009 03:24:44 GMT

If you’re anything like me and you love XBOX and IT as much as I do, you’ll get a kick out of this video. Trevor and Sam are back for their 3rd installment in the Talkin’ IT series. This time Sam has a “spinning green doughnut” that is taunting him. It’s the Great Master Russinovich and SysInternals to the rescue! Will Sam downgrade to Windows XP? Will he learn how to cut the fat from his MSCONFIG files? Will Trevor figure out what’s up with Mr. Canfield’s toupee? Watch and find out!

(Yes, we like to have a little fun as we attempt to inform IT professionals like yourself about Windows 7.)

If you aren’t familiar with Talking About Windows.com, Brandon did a piece on our first viral video here. But in all seriousness, we have a lot to say about the performance enhancements in Windows 7. OS optimization has been a key area of focus for us her at Microsoft.

Watch for new videos next week from key members of the engineering team and from IT pros like yourself.

So keep the comments coming and don’t forget to ask your questions to our Windows 7 Engineering team by joining the conversation at Talking About Windows.com

Developing for the Windows 7 Taskbar – Jump into Jump Lists – Part 1

Yochay Kiriaty — Tue, 23 Jun 2009 00:07:24 GMT

Welcome to yet another Windows 7 Taskbar post. In the previous post, Developing for the Windows 7 Taskbar – Get to Know Your Application ID , we introduced a very important component of the underlying architecture of the Taskbar, the Application ID (AppID), which is the key controller of how different applications are grouped under the same Taskbar button. The AppID also has a direct affect on how Jump List items are aggregated and populated in the Jump List.

Microsoft designed the Windows 7 Taskbar to provide users with quick and easy access to those “things” they use most frequently. “Things” can be any type of content such as pictures, music, word documents or links and shortcuts to applications or folders, or any other type of “clickable” item in Windows. By quick and easy access, we mean the ability to access commonly used programs with a single mouse click or with a significantly reduced number of clicks per operation. Quick and easy access also means users should be able to “jump” directly to those things they want to work with and start working with them in a single mouse click. To provide this functionality, the Windows 7 Taskbar introduces the concept of “Jump Lists.” More info about the reasons and background for creating the Taskbar Jump List can be found in Chaitanya’s Engineering Windows 7: The Windows 7 Taskbar post, and Windows 7 New Taskbar - An Overview video on Channel 9.

As much as I love talking about the reasons for creating the new Taskbar (since I love user functionality and usability in general) I am going to focus on the API for using the Taskbar. As a developer, you should think of a Jump List as your application's own mini Start Menu. Jump Lists bring to the surface commonly used destinations (nouns) and tasks (verbs) of a program. This enables easy user access to destinations by eliminating the need to launch the application and then load the relevant content, or by performing common tasks without launching the application in advance. The following picture illustrates how Jump Lists work with Microsoft Office Word 2007. You can see that under the “Recent” category, there is a list of recent documents that I’ve used with Office Word. Clicking on one of the items in the “Recent” list will launch Office Word with the relevant document already loaded.

We previously identified Word 2007 as an example of an application that “plays” nicely with the Windows 7 Taskbar even if that application was released a long time before the Windows 7 Taskbar was available. The Taskbar buttons are all grouped under the same Taskbar icon and the Jump list is automatically populated with the most recently used Word documents. In the next post, I will explain in detail how Jump List are populated automatically like Office Word 2007 and word documents. For this post, let’s focus on the different Jump Lists players.

The default Out-of-The-Box tasks that are shipped provide the means to launch a new instance of the application, to pin or unpin an application to the taskbar, and to close the application. You can access the Jump List by right clicking on an application icon in the Taskbar. However, as the following picture illustrates, you can opt to take more control of the Taskbar experience by customizing the context of the Jump List for your application.

Definitions from the Windows 7 SDK:

”… Destinations are items that appear in the Recent, Frequent, or custom categories (the 'Important' category in the diagram above), based on the user’s item usage. Destinations can be files, folders, Web sites, or other content-based items, but are not necessarily file-backed. Destinations can be pinned to or removed from the Jump List by the user. They are generally represented by IShellItem objects, but they can also be IShellLink objects…”

”…Tasks are common actions performed in applications that apply to all users of the application regardless of the individual usage patterns. Task can’t be pinned or removed. Tasks are represented by IShellLink objects because they are actually links (with parameters – optional) to commands – 'Actions'…”

As developer, you can:

Control Application Destinations (that is control the items you want users to be able to “Jump” directly into and start working on)
1. Destinations can be any one of the known categories such as Recent or Frequent.
2. The Custom category is just like any other Destination category, except that it allows you to create a new name for that category as well as populate it with items of your choice.
3. The Pinned category is provided for pinned items that users want to keep permanently in their Jump Lists. Please note: ONLY users can pin items in the Jump List, there is NO supported programmatic way that you, as developer, can pin an item.
4. You can completely remove the Pinned category from the Jump List so the user cannot pin items – but you might want to think twice before preventing users from pinning items in your application.
Define Common User Tasks
1. The Taskbar surfaces its own out-of-the-box tasks such as launching, pinning/unpinning, or closing the application. As developers we have no control over the Taskbar Tasks. However, we do control the User Tasks.
2. User Tasks are common tasks the application developer wants to surface at the Jump List level that will enable users to perform a task directly from the Jump List (for example, Play all music in media player without switching to media player). Usually, this will result in launching an instance of the application and performing the task, or launching another application, like Internet Explorer, when clicking on the “Go to MSN Home Page” task in the Windows Live Messenger Jump List as shown in the next picture. Again, all of the above Jump List functionality saves time and reduces the number of clicks needed to achieve the user's end goal, thereby making the user happy.

In the next post, we will dive into the Taskbar Jump List API. But first, we need to address the Taskbar programming model. The Taskbar exposes its set of APIs like any other Windows Shell component, through a set of COM interfaces. However, there are a few actions we developers can do even before starting to use the Windows Taskbar COM APIs.

MAP 4.0 Beta now available!

Stephen L Rose — Fri, 19 Jun 2009 18:52:51 GMT

Our friends over in the Solution Accelerators team just released the beta version of the Microsoft Assessment and Planning tool (MAP) 4.0. Many of you have discovered just how valuable these Solution Accelerators have been, based on the feedback we receive. We want to bring this particular release to your attention, since assessing your current environment is a critical first step to see how ready your organization is for a Windows 7 deployment.

In the case of the Microsoft Assessment and Planning tool, this agentless and scalable toolkit has the ability to discover all computers within Active Directory and workgroup environments. It performs key functions that include hardware and device inventory, hardware compatibility analysis, and generation of actionable, environment-specific IT proposals for migration to most major Microsoft technologies.

For more information, head over to Baldwin Ng’s team blog posting here. You might already know Baldwin as our resident expert on the Springboard Performance and Hardware compatibility zone.

Developing for the Windows 7 Taskbar – Application ID – Part 2

Yochay Kiriaty — Fri, 19 Jun 2009 17:06:55 GMT

[June 19th - I added a code sample and new screenshots.]

In response to some of the comments I included a link to the download and new screenshots to show the effect of changing Application ID in run time. And Just to make sure we are all on the same page here are two images to illustrate the power of AppID. You can clearly see that the same application (with the same original application ID) can have two different Taskbar buttons. You can also download the code for this application.

Just a note as response to one of the comments. Yes you can place a different Taskbar button between to windows with different AppID!

download the code for this application

You can find the managed code Taskbar object in the Windows API Code pack project.

Developing for the Windows 7 Taskbar – Application ID

Yochay Kiriaty — Thu, 18 Jun 2009 17:18:35 GMT

This is the first post in a new Windows 7 Taskbar series. One of the first Windows 7 changes that developers should pay attention to is the new Windows Taskbar. We all need to understand the functionality this feature introduces so that we can ensure that our applications work well with the Taskbar, resulting in an enhanced experience for our end users.

I assume that by now you are familiar with the basic functionality that Windows 7 Taskbar offers and the reasons behind the change we made from previous taskbar versions. If you are not familiar with and haven’t seen any demonstrations of the Windows 7 Taskbar, please watch the Windows 7 Taskbar Overview webcast on Channel 9. There are also great posts on the E7 blog like The Windows 7 Taskbar about some of the reasons we introduced the new Taskbar and desktop experience in Windows 7. I do encourage you to read these posts and watch the video so that you have some context for the technical material we are going to cover here.

The new Taskbar is probably the most noticeable change to Windows 7 when you first log on. The Windows 7 Taskbar is an application-launching and window-switching mechanism that consolidates the functions of previous Windows Desktop mechanisms, such as Quick Launch, Recent Documents, Notification Area icons, desktop shortcuts, and running application windows. Windows 7 Taskbar offers features like Jump Lists, Preview Handler, and Overlay Icons. But before we start diving into the various Windows 7 Taskbar features, let’s lay the basic foundation to our discussion and define some Windows 7 taskbar terminology.

The basic component is the Taskbar button. The Taskbar button is represented as an icon displayed on the Taskbar. As you can see in the following image, the Taskbar contains several buttons. You can tell what their status is by how they are displayed.

For example, the Media Player button has no frame or border, but simply sits directly on the Taskbar. This indicates that Media Player is not running. But it is pinned to the Taskbar, and will stay on the Taskbar unless we unpin it. A transparent frame that lets most of the color of the underlying Taskbar through the Windows Explorer button. This indicates that the app is running but is not the active application. The Visual Studio icon has a more opaque rectangular frame underlying its icon indicating that the user is actively using this app. You will also notice that Word has a “stack” of icons representing that multiple instances of Word or multiple Windows are grouped under the same Taskbar button. It is very important to understand the logic that underlies the creation, assignment, and grouping of Taskbar buttons.

A very large number of applications that run on Windows 7 (for example, Office Word 2007 and Visual Studio 2008), were not designed to work with the Windows 7 Taskbar, so how is it that they can play ball with the Taskbar, group multiple instances, and even take advantage of Word Jump Lists? Basically, a behind-the-scenes Application ID (AppID) is automatically computed and assigned to an application once you launch it. Every running application has an AppID assigned to it, either automatically computed for the app by Windows, or set by the app itself. Guess what? It is not a GUID; it is just a string (with a maximum of 128 characters), that either you provide or is being computed by the OS. All windows and applications, including Jump Lists, which have the same AppID are grouped under the same Taskbar button. Therefore, it is important to understand that every component (process, shortcut, window, Taskbar button, and document type – that is, registered file type handler) of your application has the AppID associated with it.

You may ask, "Where do AppIDs come from?" As mentioned before, the OS generates Application IDs for your application using a very simple, yet important to understand heuristic. Since in Windows 7 you can assign AppIDs to individual windows, the OS tries to extrapolate the AppID from a window. Applications usually display at least one window that the OS can query for its AppID. However, most existing apps do not have an AppID attached to each window (or, for that matter, any AppID at all), and therefore the OS falls back to the process to which the window belongs for the AppID. Each process has several properties that the OS can check, like the executable of the process. But even then, the process may not provide a granular enough separation. Different shortcuts may provide different start up command line parameters to the same executable and launch different applications (imagine a “launcher” application) that will be grouped under the same Taskbar button. In such cases, the OS has the ability to look into the specific shortcut that launched the application, to find the executable, the command line parameters, and so on. Note that if you have a register file, this registration points to an application that gets launched once you double click that file. Again, this is another way to calculate the AppID. The following image illustrates this automatic computation process.

If you are interested in really understanding the internals of the Windows 7 taskbar, a great Channel 9 video describes its underlying architecture. Watch the Rob Jarrett and Ben Bets Windows 7 Taskbar - Behind the Scenes video and, specifically for the Application ID overview, watch Jump into the Windows 7 Taskbar Jump Lists (between 29:30 and 34:40).

While the OS can compute AppIDs for you, you may want to have greater control over the AppID for a given application or even an individual window in your application. Assume that you have an application that hosts (runs) another application (like what happens when you debug an application using Visual Studio). Or you have several different applications or processes that you wish to group under the same Taskbar button. The Taskbar API offers you ways to control the Application ID per application or per window. IN ANY CASE, if you are writing a new application that targets Windows 7, we highly recommend that you provide your own application ID, as we will describe below.

OK, let’s examine the API that allows you to control the AppID associations of your application.

If you want to have a separate Taskbar button for each process (including all windows owned by that process), you can set an explicit AppID for the entire process that affects all windows within the process that do not have their own explicit AppID. Setting the explicit process AppID is very easy. All it takes is a single call to the SetCurrentProcessExplicitAppUserModelID function as shown in the following code snippet:

SetCurrentProcessExplicitAppUserModelID(c_rgszAppID[0]);

Where c_rgszAppID[0] is a pointer to a string. You should note that according to the SDK documentation, “This method must be called during an application's initial startup routine before the application presents any user interface (UI) or makes any manipulation of its Jump Lists.”

In managed code, from the latest Windows API Code Pack Library, you can use the AppID property that is part of the Taskbar object, which you can find in the Microsoft.WindowsAPICodePack.Shell.Taskbar namespace. Using that property you can set and get the application ID of a given application.

Setting the AppID for a window is a bit more complicated (but only a bit). It requires calling the SHGetPropertyStoreForWindow function and then manipulating the resulting IPropertyStore object to retrieve the requested property as shown in the following code snippet:

void SetAppID(HWND hWnd, int iAppID)
{
    IPropertyStore *pps;
    HRESULT hr = SHGetPropertyStoreForWindow(hWnd, IID_PPV_ARGS(&pps));
    if (SUCCEEDED(hr))
    {
        PROPVARIANT pv;
        if (iAppID >= 0)
        {
            hr = InitPropVariantFromString(c_rgszAppID[iAppID], &pv);
        }
        else
        {
            PropVariantInit(&pv);
        }
        if (SUCCEEDED(hr))
        {
            hr = pps->SetValue(PKEY_AppUserModel_ID, pv);
            PropVariantClear(&pv);
        }
        pps->Release();
    }
}

Here you can see how we extract the current windows property store by calling SHGetPropertyStoreForWindow, passing hWnd as refrence to the window. Next we initiate, InitPropVariantFromString(c_rgszAppID[iAppID], &pv), a property variant with a string that represents the AppID for that window. Finally, we set the value of the new property store to the window.

Unfortunately, the current Windows API Code pack doesn’t support setting specific application IDs per window, although all you need to do is add the following function to the Taskbar.cs file:

private static void SetWindowAppId(string appId)
{
    Microsoft.WindowsAPICodePack.Shell.ShellNativeMethods.SetWindowAppId
        (OwnerHandle, "name here");
}

Since the Windows API Code Pack provides the source code, you can actually check the specific implementation of SetWindowAppId function and see for yourself that it is very similar to the SetAppID example above. Note you don’t have to use the full qualified assembly name “Microsoft.WindowsAPICodePack.Shell’, but I did to help you navigate the Windows API Code Pack hierarchy.

By the way, the window AppID is dynamic, so it’s entirely possible for a window to show up as part of one Taskbar button and then change its AppID so that it appears on an entirely different Taskbar button. This has interesting effects. For example, the Jump List is attached to a Taskbar button (with a specific AppID), so the same window might show a different Jump List when it is reattached to an entirely different Taskbar button. This potentially can confuse users, so the recommended practice is to set the window AppID and stick to it, using the same process for determining the AppID every time the window displays.

You can find the managed code Taskbar object in the Windows API Code pack project.

[Sasha Goldshtein helped write this post, and you can find his original posting here].

Top 6 Things to Consider Before Buying a Small Notebook PC

Brandon LeBlanc — Wed, 17 Jun 2009 20:24:58 GMT

With small notebook PCs (sometimes called netbook PCs) now accounting for about 10% of PC sales worldwide (up to 20% of PC sales in some geographies according to leading retail sales analysts), I’m starting to get more and more questions about what a buyer should look into as he or she is shopping for a small notebook PC.

Ultimately, it depends on how you need to use your small notebook PC. While a small percentage of people are choosing to use these devices as their only computer, most are finding them better suited as a “companion PC” to a traditional desktop or notebook (for example, I use my Dell Mini 9 as a “companion PC” to my desktop PCs at work and at home). They are great for staying more conveniently connected on-the-go (for example: browsing the web on the train home from work, sending email from a coffee shop, or just getting office and/or personal tasks done).

There’s a small notebook PC out there for everyone depending on budget and hardware needs – but sometimes the different choices can get a little overwhelming.

To help out, I’ve pulled together a “checklist” of basic questions that you’ll want to think about before handing the cashier your credit card:

1. Is it easy to use?

This question may seem obvious, but when you think about it, it’s probably the most important one on this list. How are you going to be using your small notebook PC? Are you using this as a companion to your primary desktop or laptop PC? If so, then you’ll want it to have the same interface and experience as your primary machine so you can seamlessly move back and forth without any confusion or hassle and easily transfer and share files between your computers. You’ll also want to be sure that it can easily connect to a wireless or 3G broadband network so you can instantly get online wherever you are. And of course, make sure that there’s a built in tool, like Windows Instant Search, to help you instantly find your, music, photos and files…after all, your computer isn’t very handy if you can’t find your stuff on it!

2. Will it work with my stuff?

Think about what software you expect to use on your small notebook PC. Check for compatibility with your cameras, printers, music players, webcams, and anything else that you expect to connect, such as a GPS unit or mobile phone. Windows supports nearly 3,000 printers, over 700 digital cameras, 240 webcams, and 180 digital video cameras, as well as hundreds of more specialized devices. It also runs more than 10,000 applications, and it’s the only OS that runs Microsoft Office, iTunes and Quicken. This means that whatever it is you use, chances are it works with Windows. It’s also a good idea to make sure that your computer works with free, easy to use tools for email, blogging, chatting, working with photos and movies, online storage, and syncing your stuff between your PCs. I use Windows Live Essentials and Windows Live SkyDrive to do these things on my computers.

3. Is it the right size?

While screen and keyboard size are personal decisions, I can tell you that many of today’s small notebook PCs come with 9” or 10” screens for a good reason. Machines this size offer a better balance between lightweight portability, having a screen big enough to be productive with more than one window at once, and a keyboard that’s comfortable enough for most people’s hands. My Dell Mini 9 has a 8.9” screen. The size doesn’t bother me much but if I were to go out and buy another small notebook PC, I would likely go with a 10” screen. If you find that even 10” is still too small for you though, there are a number of larger but still lightweight notebooks at pretty affordable prices that may work better for your needs over a small notebook PC. If you do decide to go that route, check out the Windows Laptop Scout, which will help you find exactly the right machine for your needs.

4. Does it have the hardware horsepower I need?

When it comes to hardware, there are four key areas to consider – screen & keyboard size, processor speed, RAM, and storage. Screen and keyboard size we covered earlier, but in terms of the processor, look for a machine with at least a 1GHz CPU, and for RAM, get at least 1GB. 1GB of RAM is what my machine came with, but I added another 1GB to it for an extra performance boost. Many models allow you to add at least an extra stick of memory. If you buy a small notebook PC and want to give it more power down the road, having this ability is quite nice.

Storage is largely a personal call, and how much you need really depends on what you expect to do with your small notebook PC. If you want to put your pictures and music on it, then you probably want a 120GB or larger Hard Disk Drive. If you’re just looking to do basic email and web browsing, you might go for a smaller Solid State Drive (typically, these are 8-32GB). SSDs often run cooler and quieter, and may use less power, which means they can potentially get you a bit of boost in battery life. My Dell Mini 9 came with a 16GB SSD, but I found that it wasn’t enough space for me so I replaced it with a 32GB SSD. I also purchased a 320GB My Passport Essential from Western Digital I carry around with me everywhere as well for the added storage.

I recommend checking out CNET’s reviews, as well as the great information, reviews and tips on Liliputing to help you find a small notebook PC with exactly the specs you want.

5. Will I be safe online?

You’re probably going to be online quite a bit, so you’ll want to make sure you can browse, chat, and share safely. Key security features to look for in both your OS and browser are comprehensive phishing and Cross-Site Scripting filters along with ClickJacking protection to help guard against identity theft, built-in spyware and malware protection, comprehensive parental controls, a built-in firewall, and a private browsing model. As an FYI – Internet Explorer 8 in combination with Windows Live Family Safety can do all these things for you.

6. What level of support do I need?

Making sure that you can get the right kind of support when you need it is critical. It’s a good idea to get a small notebook PC that has built-in features to keep your gear up and running, such as automatic self-diagnosing tools and a comprehensive built-in system to help you automatically get security, OS and software updates, without having to track them down yourself and manually install them 1-by-1. When you do run into a need for assistance, you’ll also be better off with multiple support options including online resources, a call-in tech support center, or in-person help at a repair shop or retailer.

Hopefully, if you’re on the market for a new small notebook PC this checklist of questions will come in handy in helping you with your buying decision!

Windows 7 Deep Dive Lab Event

Yochay Kiriaty — Wed, 17 Jun 2009 07:21:22 GMT

In this post I will deviate from our normal routine of writing about Windows 7 features, APIs, and code samples, and will instead talk a little about an amazing opportunity to attend the Windows 7 "Deep Dive" Development Lab at the Microsoft Campus in Redmond, Washington on 6-8 July 2009.

A Deep Dive lab enables you to work on scenarios of your choice with experts from the Windows 7 product team. This is not a traditional training event. This is a special onetime event and a unique opportunity to meet the people who build Windows 7. The agenda includes a few presentations and some lab time, but our goal is for you to work on your own application(s) with our experts, focusing on how Windows 7 features like Sensor and Location, Taskbar, Multi-Touch, Libraries, Graphics, Ribbon, XPS & Print Path, Performance and Instrumentation, Troubleshooting Pack, and Application Compatibility can add value to your applications.

If accepted into the Deep Dive lab, you will be working on your own applications with members from the Windows 7 product teams. Meetings with specific team members may also be arranged as required and upon request. We are also available to assist you with Windows 7 compatibility issues to ensure that your application is Windows 7 compatible. Each participating group gets its own lab room, which accommodates up to 4 people, in which to develop the solution.

Who can come?

Up to four people from each company, normally developers and architects.

What does it cost?

There is no charge for the event. Microsoft will provide a light breakfast and lunch during the 3-day event, and will also provide one on-site dinner. You are responsible for any other expenses including accommodations, travel costs to Redmond, and evening meals.

How do I nominate my organization?

Due to high demand, Deep Dive developer labs have extremely limited capacity, and enrollment is based on a nomination process. Please complete the nomination form and e-mail it to dpewin7@microsoft.com. Nominations will be evaluated based on the project scenario and its status. The information you provide will also help us to prepare for your arrival at the Lab. You should receive an acknowledgement e-mail within few business days. Once we have verified your nomination form and selected your team as participants, we will send you more detailed event logistics.

Please do NOT make travel arrangements until your participation has been confirmed.

Windows 7 Deep Dive Nomination Form

Primary Contact - Provide primary contact information for communicating information related to the event:

Primary Contact Name:
Primary Contact E-mail:
Primary Contact Phone:

Deep Dive Attendees - List the names of the individuals likely to attend the Deep Dive Lab and their roles on the team:

Project / Product Details - Provide some background information about the application(s) that you wish to work on during the event:

Project Name:
Scheduled Release Date:
Description (Include purpose, software environment, and users):

Windows 7 Features - Provide a list of the Windows 7 features you wish to incorporate into your application:

Please complete the nomination form on the next page and e-mail it to dpewin7@microsoft.com.

Find The Windows Blog on Facebook!

Brandon LeBlanc — Wed, 17 Jun 2009 04:02:01 GMT

You can now find The Windows Blog on Facebook and become a fan! Just click on the button below to go to our Facebook Page.

Remember, you can also follow The Windows Blog on Twitter as well.

Keyboard Shortcuts for Windows Media Player in Windows 7

Brandon LeBlanc — Tue, 16 Jun 2009 23:43:10 GMT

In Windows 7, we’ve improved how people can play and manage their digital media content (like music and videos) through Windows Media Player. Not only did we give Windows Media Player a face lift, it also takes advantage of key Windows 7 features such as the new Windows Taskbar, HomeGroup and Jump Lists. With all the new stuff packed into Windows Media Player, I thought it might be a good idea to highlight some tips for using Windows Media Player.

Starting today, I plan to do a series of 6 blog posts over the course of the next 3 weeks, each dedicated to a single tip for Windows Media Player.

Today’s Tip: Keyboard Shortcuts!

Below is a list of keyboard shortcuts you can use for a variety of activities in Windows Media Player ranging from switching to Player Mode to turning on or off shuffle to shifting between play speeds. If you’re a keyboard fiend – this list is a must-have.

Shortcut	Action	State
Ctrl + 1	Switches to library mode	From any mode
Ctrl + 2	Switches to skin mode	From any mode
Ctrl + 3	Switches to player mode	From any mode except full screen
Ctrl + 7	Add to Play	In library mode
Ctrl + 8	Add to Burn	In library mode
Ctrl + 9	Add to Sync	In library mode
Ctrl + A	Selects everything in a list	In the library or list
Ctrl + B	Previous (Item or Chapter)	With content playing
Ctrl + E	Focus on Search text box and switch to library mode if not there
Ctrl + F	Next (Item or Chapter)	With content playing
Ctrl + H	Turn on/off shuffle mode
Ctrl + J	Eject	In any mode
Ctrl + M	Toggle menu bar in library	In any mode
Ctrl + N	Create playlist	In library mode
Ctrl + O	Shows Open Dialog	In any mode
Ctrl + P	Play/Pause Toggle	With content queued up
Ctrl + Q	Adds selected track to open list	Default is Play list
Ctrl + S	Stops Playback	With content playing
Ctrl + T	Turn on/off repeat mode	In any mode
Ctrl + U	Shows Open URL Dialog	In any mode
Ctrl + W	Stops playback	With content playing or paused
Ctrl + Shift + B	Rewinds playing content	With DVD playing
Ctrl + Shift + C	Caption On/Off Toggle	Playing content which has captions
Ctrl + Shift + F	Fast forwards playing content	With content playing
Ctrl + Shift + G	Play Speed Fast	With content playing
Ctrl + Shift + N	Play Speed Normal	With content playing
Ctrl + Shift + S	Play Speed Slow	With content playing
Ctrl + Right Arrow	Next playlist in playlist history	Focus not on Seek bar
Ctrl + Left Arrow	Previous playlist in playlist history	Focus not on Seek bar
Ctrl + Right Arrow	Skip forward (large increment)	Focus on Seek bar
Ctrl + Left Arrow	Skip backward (large increment)	Focus on Seek bar
Shift + Right Arrow	Skip forward (small increment)	Focus on Seek bar
Shift + Left Arrow	Skip backward (small increment)	Focus on Seek bar
Right Arrow	Skip forward	Focus on Seek bar
Left Arrow	Skip backward	Focus on Seek bar
Ctrl + Click	Resize player to image	In Now Playing mode
Escape	Return to Now Playing	Full Screen Mode
F1	Opens Help file	In any mode
F2	Edit meta data column	In library mode with an item selected
F4	Switch view mode	In library mode, focus in list view
F5	Refresh screen	Focus on library or in online services
F6	Increases album art	Focus in list view
Shift + F6	Decreases album art	Focus in list view
F7	Mutes sound	In any mode
F8	Decrease sound volume	In any mode
F9	Increases sound volume	In any mode
F10	Show menu bar in library	From any mode
Shift + F10	Context menu shortcut	In any mode
Alt + 1	Video Size 50%	In Now Playing or skin mode, with a video playing
Alt + 2	Video Size 100%	In Now Playing or skin mode, with a video playing
Alt + 3	Video Size 200%	In Now Playing or skin mode, with a video playing
Alt + Enter	Full Screen Toggle	In Now Playing, skin, or full screen mode

Stay tuned – I’ll have another tip for Windows Media Player coming up soon!

NOTE: These tips are for Windows Media Player in Windows 7 only.

Understanding XP Mode

Stephen L Rose — Tue, 16 Jun 2009 18:27:37 GMT

(reposted from our blog of May 26th)

After we announced Windows XP Mode, I sat down again with Jeremy Chapman at the Microsoft Management Summit in Las Vegas a few weeks ago to find out what he thought about Windows XP Mode as a solution for solving application compatibility issues.

Stephen Rose: Hi Jeremy, seems like I’m interviewing you a lot lately. So we’re at MMS here in Las Vegas and we just announced the Windows 7 Release Candidate and Windows XP Mode as a solution for allowing applications to run within a Windows XP session on a Windows 7 machine. What do you think about this technology? Will this solve everything for people having problems moving off Windows XP or Internet Explorer 6?

Jeremy Chapman: Windows XP Mode adds the seamless virtual desktop integration like we saw in Microsoft Enterprise Desktop Virtualization (MEDV), so you can see applications within the virtual operating system in the start menu:

And you can view applications within the physical operating system’s desktop without showing the entire virtual machine desktop.

It definitely makes the use of Virtual PC technologies much easier for the average user. As we’ve seen for the last decade or so, you can run legacy applications under the context of the legacy operating system. Initially that sounds like a good thing, as Virtual PC always has.

Stephen Rose: Explain what you mean by initially.

Jeremy Chapman: To the undiscerning eye, this looks like an easy fix and for many in sales and marketing roles, it might sound like a silver bullet for application compatibility. Despite the more intuitive user experience, the IT management issues with that are essentially the same as they have been for the last ten years or so with Virtual PC.

Stephen Rose: What do you see as the challenges with this technology then?

Jeremy Chapman: First, there are two operating systems to manage per userSecond, while we can automate and customize full operating system provisioning, it isn’t so easy to custom provision the virtual machine according to user roles and needs. Third, by default the virtual PC user account is a local administrator.

Stephen Rose: Ok, so is there anything that helps IT pros with any of these areas?

Jeremy Chapman: Definitely, MED-V (Microsoft Enterprise Desktop Virtualization) adds the control so you can sandbox the virtual PC environment from the physical environment. It also provides the administrative tools to provision within the virtual environment. There is granular control over how the two operating systems behave with one another and you can even pre-define which websites or web-based Line-of-Business applications need to be automatically invoked in the virtual machine’s web browser (Internet Explorer 6 by default). MED-V is also self adjusting as the virtual PC memory allocation based on available RAM on host, so that the virtual PC does not take significant resources from the user. Features like TrimTransfer update a master Virtual PC image, and MED-V will automatically distribute and apply the changes to all endpoints. Finally, MED-V will work on both Windows 7 and Windows Vista, and will not require processor-based virtualization support

Stephen Rose: That definitely sounds like the more manageable solution, but is running Virtual PC and MED-V the only recommended solution for Windows 7?

Jeremy Chapman: From the application compatibility perspective, the best thing to do is to get applications that run natively without any virtualization aids, recoding, compatibility fixes or compatibility modes needed. If you own the code and can recode the application, then do that. If you can’t recode a line-of-business application or are not dependent on support for a third party application, you can try compatibility fixes – or “shims” – to remediate the application. Finally, when all these options aren’t possible, then look into legacy operating system virtualization. If you have exhausted all other options for application remediation and intend on using Windows XP Mode, then I’d recommend following all the best practices in the Windows XP Security Compliance Management Toolkit to secure the virtual environment and manage configuration with Group Policy and desired configuration management in System Center Configuration Manager.

Stephen Rose: So who should be using Windows XP Mode then?

Jeremy Chapman: For individual users or smaller organizations where desktops are not managed, Windows XP Mode is a relatively easy solution to get working. You’ll need to find installation media for those older applications and manually install them, but it can get them working until you port everything over to the physical operating system.

Stephen Rose: So for a transitional period to the new OS, these legacy client virtualization tools can help people run their incompatible legacy applications. Is there anything else to remember with Virtual Windows XP?

Jeremy Chapman: We haven’t talked about hardware yet. So hardware needs to have hardware virtualization – Intel VT or AMDV – and have it enabled in the BIOS. Most business grade hardware produced in the last 2-3 years has that, but netbooks and older PCs often do not meet this requirement. The virtual machine also uses memory, so you’ll probably want to use PCs with 2 GB or more RAM.

Stephen Rose: Good advice. So where can people find more information on Windows XP Mode?

Jeremy Chapman: Check out Scott Woodgate’s blog post on the Windows Team Blog and Scott’s Q&A on PressPass. There is also a Virtual PC Tips and Tricks FAQ on Springboard located here

Stephen Rose: Thanks again for your time Jeremy.