I started off in Visual Studio using the default setup process project and for the most part it worked absolutely fine. In VS2005 I’d build my project, I’d create a setup.exe wrapper around my MSI, then bundle it in a self extracting zip file to launch setup.exe. That worked for me and I liked the setup.

Then came Visual Studio 2008 and that all changed. Microsoft didn’t seem to change too much in the setup process yet I was finding my setup projects were crashing constantly and consistently. I discovered that with the 2008 setup system the .exe wrapper was calling the msi and immediately exiting allowing the .msi to carry on. Yet the WinZip self extracting .exe tool was waiting for the .exe to finish before cleaning up the files. Effectively as soon as setup.exe finished, WinZip deleted the .msi even if it was still being used.

After hours of research I couldn’t find a way to change this so I decided to look for decent applications out there that not only would replicate what the Visual Studio setup project would do, but actually enhance it.

My requirements were pretty straight forward.

1. It must detect pre-requisites such as .NET Framework, screen resolutions, etc
2. Allow me to put custom settings in the registry or shortcut folders
3. Allow me to create custom components and features that the user can toggle those features on or off
4. I wanted to be able to associate file extensions with my applications
5. I wanted to be able to perform actions after an installation or in uninstall (such as add a component to the Visual Studio toolbox)

Nice to haves would be to allow me to have licensing integrated at the installer level rather than the application level, customising the interface, etc

My research led me to a number of applications, but the only one that grabbed me was an application called Advanced Installer by Caphyon.

This software comes in a number of different versions, most notably a free version too.  I elected for the professional version though but the comparisons are available from their website.

What amazed me about this software was it was so simple to use and build my installer yet the interface to do so was very straight forward, including a number of built in wizards for creating shortcuts, file extension associations, etc.

So much so that I migrated all of my Windows apps to Advanced Installer as soon as I could.

The current version, just released, is version 7.0, which includes an installer for the Windows Mobile Platform.  For me this release is going to solve a problem I hadn’t even researched.  Basically I am currently developing a lightweight app for Windows that I have thought in passing would be perfect for Windows Mobile too, yet I hadn’t actually thought how to deploy for Windows Mobile as I’ve never written a Windows Mobile app before.

So into my Inbox this morning, pops an email from Caphyon telling me about version 7.0 and it’s new features.  I haven’t tested this feature yet, but if it works as well as the rest of the application does, this is going to solve hours or even days in working out how to deploy my applications on the Windows Mobile Platform.

I’m looking forward to their new GUI interface enhancements to the end-user installation screens as well as the MSIE 8 detection. The one other feature that I’m looking forward to is, in version 7.0 they have added a feature to allow detection of free ports on the PC on installation.  This will solve many issues with connectivity that user’s face in their own apps all the time!

Basically guys, if you want a decent installer for Windows applications, and you don’t want to spend a fortune, there is only one way to go… Advanced Installer.

However the problem with this approach is the Background of the PictureBox isn’t truely transparent, it simply inherits the background colour or background image of the control in the layer beneath it.

So in Visual Studio I have the following (note the scroll bar at the bottom right hand corner which can’t be seen or accessed due to the image overlaying it)

However I found a small function that will take the colour of the PictureBox at pixel position x=0, y=0 (which in my image happens to be transparent and apply that to all other transparent elements.

public static System.Drawing.Drawing2D.GraphicsPath Transparent(Image im)
        {
            int x;
            int y;
            Bitmap bmp = new Bitmap(im);
            System.Drawing.Drawing2D.GraphicsPath gp = new System.Drawing.Drawing2D.GraphicsPath();
            Color mask = bmp.GetPixel(0, 0);

            for (x = 0; x <= bmp.Width - 1; x++)
            {
                for (y = 0; y <= bmp.Height - 1; y++)
                {
                    if (!bmp.GetPixel(x, y).Equals(mask))
                    {
                        gp.AddRectangle(new Rectangle(x, y, 1, 1));
                    }
                }
            }
            bmp.Dispose();
            return gp;

        }

Then in your form load event handler

System.Drawing.Drawing2D.GraphicsPath gp = Resources.Images.Transparent(pictureBox1.Image);
pictureBox1.Region = new System.Drawing.Region(gp);

And voila, when you compile your application you'll get

Scenario

I want to create a URL handler in Windows and send that message to my already running .NET application.  For example I create a url handler called myapp: and I create a link in HTML to myapp://www.richardhyland.com/, I want to send that URL to my application, let’s call it MyApp.exe and do something with it.

Now I can quite easily create a URL handler in the Windows registry and call MyApp.exe, but that will create a new instance of the application, what I want  to do is detect to see if MyApp.exe is already running.  If it is then send the URL to that process and if it isn’t, load MyApp.exe.

My Solution

After many hours with Google, I discovered this cannot be done using managed code, so I had to delve into the scary arena of unmanaged code in .NET.

I first set up MyApp.exe to recieve the message.

protected override void WndProc(ref System.Windows.Forms.Message m)
{
  if (m.Msg == 0x400)
  {
    // We've recieved a message from handler.exe (we must now decode the IntPtr and deal with it)
    try
    {
      BS.BuildString(m.LParam);
    }
    catch
    {
    }
  }
  base.WndProc(ref m);
}

void BS_StringOK(string Result)
{
  if (Result.StartsWith("myapp://"))
  {
    Result = Result.Substring(8);
  }
  string strUrl = "http://" + Result.ToString();

  this.funcDoSomething(strUrl);
}

What we’ve done here is override the WndProc function in the application, examined it for a string and passed it to a function called funcDoSomething()

Next we can create a simple, small .exe for the URL handler to open.

Inside the main class of the handler.exe we need to declare

[DllImport("user32.dll")]
private static extern
bool SetForegroundWindow(IntPtr hWnd);

[DllImport("user32.dll")]
private static extern
bool ShowWindowAsync(IntPtr hWnd, int nCmdShow);

[DllImport("user32.dll")]
private static extern
bool IsIconic(IntPtr hWnd);

private const int SW_HIDE = 0;
private const int SW_SHOWNORMAL = 1;
private const int SW_SHOWMINIMIZED = 2;
private const int SW_SHOWMAXIMIZED = 3;
private const int SW_SHOWNOACTIVATE = 4;
private const int SW_RESTORE = 9;
private const int SW_SHOWDEFAULT = 10;

[StructLayout(LayoutKind.Sequential)]
public struct COPYDATASTRUCT
{
   public int dwData;
   public int cbData;
   public int lpData;
}

Now you can get the string as an arguement in your form loader and process store it to a string

Now let’s detect to see if MyApp is running

Process[] myProcesses = Process.GetProcessesByName("MyApp");

if (myProcesses.Length >= 1) {
 int n = 0;        // assume the other process is at index 0
 // get the window handle
 IntPtr hWnd = myProcesses[n].MainWindowHandle;

 // if iconic, we need to restore the window
 if (IsIconic(hWnd))
 {
   ShowWindowAsync(hWnd, SW_RESTORE);
 }

 // bring it to the foreground
 SetForegroundWindow(hWnd);

 // Process the message through my builder DLL, see later
 RH.SendMessage.BuildString BS = new RH.SendMessage.BuildString();
 BS.PostString(hWnd, 0x400, 0, strUrl);

 // Message sent to exit
 Application.Exit();
}
else
{
 // Application not running so, start it
 string exeDir = System.Reflection.Assembly.GetExecutingAssembly().Location.Replace("\\handler.exe", "");
 System.Diagnostics.Process.Start(exeDir + "\\MyApp.exe", strURL);
 Application.Exit();
}

Finally we need to detail the String Parser DLL that is mentioned in the above code. This I found online, and it is in Visual Basic

Imports System.Text

Public Class BuildString

    Private Declare Function PostMessage Lib "user32.dll" _
Alias "PostMessageA" (ByVal HWnd As IntPtr, ByVal WMsg As _
Integer, ByVal WParam As Integer, ByVal LParam As Integer) _
As Integer
    Public Event StringOK(ByVal Result As String)
    Private HWnd As IntPtr
    Private WMsg As Integer = 0
    Private WParam As Integer = 0
    Private LParam As String = ""
    Private tempA(-1) As Byte
    Private enc As Encoding = Encoding.UTF8

    Public Property Encode() As Encoding
        Get
            Return enc
        End Get
        Set(ByVal value As Encoding)
            enc = value
        End Set
    End Property

    Public Sub BuildString(ByVal b As IntPtr)
        If b <> 0 Then
            'build temp array
            Dim tempB(tempA.Length) As Byte
            tempA.CopyTo(tempB, 0)
            tempB(tempA.Length) = b
            ReDim tempA(tempB.Length - 1)
            tempB.CopyTo(tempA, 0)
        Else
            'decode byte array to string
            Dim s As String
            If enc Is Encoding.UTF8 Then
                s = Encoding.UTF8.GetString(tempA)
            ElseIf enc Is Encoding.Unicode Then
                s = Encoding.Unicode.GetString(tempA)
            ElseIf enc Is Encoding.ASCII Then
                s = Encoding.ASCII.GetString(tempA)
            Else
                s = Encoding.Default.GetString(tempA)
            End If
            'send out result string via event
            RaiseEvent StringOK(s)
            ReDim tempA(-1)
        End If
    End Sub

    Public Sub PostString(ByVal HWnd As IntPtr, ByVal WMsg _
As Integer, ByVal WParam As Integer, ByVal LParam As String)
        Me.HWnd = HWnd
        Me.WMsg = WMsg
        Me.WParam = WParam
        Me.LParam = LParam
        'create a new thread to post window message
        Dim t As Threading.Thread
        t = New Threading.Thread(AddressOf SendString)
        t.Start()
    End Sub

    Private Sub SendString()
        'create byte array
        Dim ba() As Byte
        'encode string to byte array
        If enc Is Encoding.UTF8 Then
            ba = Encoding.UTF8.GetBytes(lParam)
        ElseIf enc Is Encoding.Unicode Then
            ba = Encoding.Unicode.GetBytes(lParam)
        ElseIf enc Is Encoding.ASCII Then
            ba = Encoding.ASCII.GetBytes(lParam)
        Else
            ba = Encoding.Default.GetBytes(lParam)
        End If
        Dim i As Integer
        For i = 0 To ba.Length - 1
            'start post message
            PostMessage(hwnd, wMsg, wParam, ba(i))
        Next
        'post a terminator message to destination window
        PostMessage(hwnd, wMsg, wParam, 0)
    End Sub
End Class

And voila, that is now I sent a message from one running .NET application to another without starting a new process of the recieving .NET application.