It was very interesting to talk with a Microsoft developer about the requirements that needs to be met for a Metro style app in the Windows 8 app store. There are very high standards especially regarding the look & feel of the application.

At the moment I especially want to get a HTML5-based vocabulary trainer ready for Windows 8. As a result of this App Excellence Lab I got a token that I can use to register at the Windows 8 app store before the official start. Additionally registration is free with this token for two years.

Did you attend to a Windows 8 App Excellence Lab, too?

The speaker explained some details about the new operating system and especially the new Metro apps from a developer perspective. Although it still was interesting, I expected some more new information in such a seminar.

Anyway, it was great to meet some friends again and catering was good, too.

Did you attend to this event, too?

But the result was this error message as soon as I tried to open one of my derived from classes in the Visual Studio form designer:

The designer must create an instance of type <type name>, but it can't because the type is declared as abstract.

Hereupon I’ve searched for a solution in the web and it seems that I was not the only one that had the idea to derive some form classes from an abstract base class. To solve the problem I’ve created a dummy implementation of my abstract base class and derived the form classes from this dummy implementation. This way the form classes can be displayed in the Visual Studio form designer again.

In C# the classes look like this then:

public abstract partial class BaseForm : Form
{
  // Methods of your abstract class...
}

#if DEBUG
public class BaseFormImpl : BaseForm
{
  // The dummy implementation of the abstract BaseForm class.
}
#endif

#if DEBUG
public partial class RealForm : BaseFormImpl
#else
public partial class RealForm : BaseForm
#endif
{
  // One of the forms extending the base form.
}

And for VB .NET developers it looks like this:

Public MustInherit Partial Class BaseForm
  Inherits Form
  ' Methods of the abstract base class...
End Class

#if DEBUG
Public Class BaseFormImpl
  Inherits BaseForm
  ' The dummy implementation of the abstract BaseForm class.
End Class
#endif

Public Partial Class RealForm
#if DEBUG
  Inherits BaseFormImpl
#else
  Inherits BaseForm
#endif
  ' One of the forms extending the base form.
End Class

Probably you have noticed the compiler directives: obviously that’s not necessary that the forms work correctly inside the form designer again. But I don’t like to have unnecessary code inside the released product (and the dummy implementation of the abstract BaseForm class is really useless). Therefore I used these conditional compiler directives to make sure that this dummy class is only used in debug mode.

Did you come across this issue yourself already, too?

The first decision to make is which programming language you want to use for developing the Internet Explorer toolbar. I did some research in the web and found examples for C++, Visual Basic 6 and .NET. There seem to be some visual styles issues; it obviously does not look so good on Windows Vista and Windows 7 systems by using the C++ version. And as I really don’t like to develop in Visual Basic 6 anymore, I decided to go the .NET way. The only disadvantage of this decision is that the user needs to have the .NET Framework 2.0 (or higher) installed on the system. But I can live with that, because it is very common already.

Since almost all of my products are developed in .NET, I already had the Visual Studio 2008 installed on my computer. If not, you’ll need at least the Express Edition (version 2005 should be enough, too) for the next steps. I decided to develop the toolbar in C#, but Visual Basic .NET could do the same thing, of course.

As a good starting point I found this and this article at the Code Project webpage. If you want to read more about the COM component, you can also read the C++ tutorial, but that’s not necessarily needed. By using the demo source code of those articles you should get a working toolbar – at least on a Windows XP system. But there were some issues I came across that needed to be fixed and therefore I will describe them in more detail here:

Making Toolbar Show up Correctly on All Operating Systems

By using the demo code of the articles mentioned above, I got the toolbar to work quite fast on my Windows XP testing machine. I was naively thinking that if the toolbar works on Windows XP with Internet Explorer 8, it will also work on Windows Vista and Windows 7 with the same Internet Explorer version. But indeed, I had to learn that this is absolutely not the case! It either just does not show up at all or so far on the right side, that you can only see the toolbar if you have a horizontal resolution of at least 2,000 pixels. So I had to search for a solution, but most changes to the code resulted in the toolbar working either on the one or on the other operating system or browser version combination. After some hours of frustrated testing, I changed the GetBandInfo procedure of the BandObjectsLib class in the following way. Although I’m still not absolutely sure why, it works fine now on all operating system:

public virtual void GetBandInfo(UInt32 dwBandID, UInt32 dwViewMode, ref DESKBANDINFO dbi)
{
    if ((dbi.dwMask & DBIM.MINSIZE) != 0)
    {
        dbi.ptMinSize.X = this.MinimumSize.Width;
        dbi.ptMinSize.Y = this.MinimumSize.Height;
    }

    if ((dbi.dwMask & DBIM.MAXSIZE) != 0)
    {
        dbi.ptMaxSize.X = this.MaximumSize.Width;
        dbi.ptMaxSize.Y = this.MaximumSize.Height;
    }

    if ((dbi.dwMask & DBIM.ACTUAL) != 0)
    {
        dbi.ptActual.X = this.Size.Width;
        dbi.ptActual.Y = this.Size.Height;
    }

    if ((dbi.dwMask & DBIM.BKCOLOR) != 0)
    {
        dbi.dwMask &= ~DBIM.BKCOLOR;
    }

    dbi.dwModeFlags = DBIMF.BREAK;
}

Nicer Appearance on Windows XP and above

If you don’t add the following event handler to the BandObjectsLib class, your toolbar will still work, but will just not look very good on Windows XP and above. The if-statement in the event function additionally makes sure that the toolbar still works on older operating systems like Windows 98, 2000 and ME. Otherwise it would throw an exception on these operating systems. Here is the code I’ve used to get it to work correctly on all operating systems:

[DllImport("uxtheme", ExactSpelling = true)]
public extern static Int32 DrawThemeParentBackground(IntPtr hWnd, IntPtr hdc,
                                                     ref Rectangle pRect);

protected override void OnPaintBackground(PaintEventArgs e)
{
    if (System.Environment.OSVersion.Platform >= PlatformID.Win32NT &&
           (Environment.OSVersion.Version.Major == 5 &&
            Environment.OSVersion.Version.Minor >= 1 ||
            Environment.OSVersion.Version.Major >= 6) &&
           this.BackColor == Color.Transparent)
    {
        // Only if operating system is Windows XP or higher
        IntPtr hdc = e.Graphics.GetHdc();
        Rectangle rec = new Rectangle(e.ClipRectangle.Left,
            e.ClipRectangle.Top, e.ClipRectangle.Width, e.ClipRectangle.Height);
        DrawThemeParentBackground(this.Handle, hdc, ref rec);
        e.Graphics.ReleaseHdc(hdc);
    }
    else
    {
        base.OnPaintBackground(e);
    }
}

No Serialization Allowed

When developing a Firefox toolbar you can use the Mozilla preferences service to store and load user-defined values inside Firefox itself. Because there is no equivalent in Internet Explorer and I’m using XML serialization in many of my other .NET products, I wanted to use it in the toolbar project, too. This worked fine at first sight, but if the Protected Mode is enabled in Internet Explorer 8 (and it is by default, at least since Windows Vista), it shows an ugly warning dialog to the user whenever the toolbar is initialized. I won’t explain the reason in detail here, but just don’t use serialization in Internet Explorer toolbars. You can save user-defined values either without serialization in the file system below the local application data directory or simply by using the registry.

Automatic Online Update

As I did in the Firefox version, I also wanted the Internet Explorer toolbar to come with an automatic update feature. Because there is no update system for toolbars in Firefox, you have to implement it yourself. But this is quite easy, because you can use, as in any other .NET application, the WebClient class for doing a HTTP request to first ask if there is a new update available and then to receive the update file if needed. On the server side I have a small PHP script handling the update requests. The update file which is downloaded is the normal setup executable that just overrides all files with the new ones. The only thing you have to care about is the way you call the executable setup file after downloading, because otherwise a User Account Control (UAC) prompt will be shown. I’ve written this procedure that you can use for executing a file from within the toolbar code without any warning displayed to the user:

private void startProcess(string fileName, string arguments)
{
    System.Diagnostics.ProcessStartInfo startInfo =
        new System.Diagnostics.ProcessStartInfo();
    startInfo.UseShellExecute = true;
    startInfo.WorkingDirectory = Environment.CurrentDirectory;
    startInfo.FileName = fileName;
    if (Environment.OSVersion.Platform >= PlatformID.Win32NT &&
            Environment.OSVersion.Version.Major >= 6)
        // Only if operating system is Windows Vista or higher
        startInfo.Verb = "runas";
    else
        startInfo.Verb = "open";
    startInfo.Arguments = arguments;
    startInfo.ErrorDialog = true;
    try
    {
        System.Diagnostics.Process process = System.Diagnostics.Process.Start(startInfo);
        process.WaitForExit();

        MessageBox.Show(objToolbarData["msg.restartBrowserText"],
                        objToolbarData["msg.restartBrowserTitle"],
                        MessageBoxButtons.OK, MessageBoxIcon.Information);
    }
    catch (Exception ex)
    {
        if (debugMode) MessageBox.Show(ex.ToString());
    }
}

Uninstall Button Inside the Toolbar

That’s the only thing which is easier to implement in Internet Explorer than in Firefox; it is enough to call the uninstall executable (again with the startProcess procedure above) of the installation system (see next post###) to uninstall the toolbar again. It will disappear then after browser has been restarted (just as on Firefox).

It’s done; the Internet Explorer version of our toolbar is ready, too! It will work on Internet Explorer 6 or higher running on Windows 98 or higher with an installed .NET Framework 2.0.

In the next post I’ll explain how we get the toolbars installed.

Contents of Post Series “Developing a Browser Toolbar”:

• Introduction
• Mozilla Firefox
• Microsoft Internet Explorer
• Installation System
• Summary