The ComboBox with MouseWheel redirect

The class i implemented for this solution just overrides the WndProc function, which handles all the messages sent to the control. It then reroutes mouse wheel events to another control (the reciever) through the Win32 API function SendMessage.
That’s it…

public class ComboBoxMWRedirect : ComboBox
{
    [DllImport("user32.dll", CharSet = CharSet.Auto)]
    private static extern IntPtr SendMessage(
        IntPtr hWnd,
        int message,
        IntPtr WParam,
        IntPtr LParam);

    private const int WM_MOUSEWHEEL = 0x020A;
    private Control _reciever;

    //needed for designer support
    private ComboBoxMWRedirect() {}

    public ComboBoxMWRedirect(Control reciever)
    {
        _reciever = reciever;
    }

    protected override void WndProc(ref Message message)
    {
        if (message.Msg == WM_MOUSEWHEEL)
        {
            //route mouse wheel messages to the reciever
            SendMessage(
                _reciever.Handle,
                message.Msg,
                message.WParam,
                message.LParam);
        }
        else
        {
            //route all other messages on to the base class
            base.WndProc(ref message);
        }
    }
}

Now to have one of your ComboBoxes redirect the mouse wheel, just use one of these instead, and specify the recieving control when you call the constructor. If, for instance, i want to redirect to a DataGridView calle dataGridView1 i would construct the redirecting ComboBox like this:

ComboBoxMWRedirect cb = new ComboBoxMWRedirect(dataGridView1);

Completely avoiding the event

The code can also be used to avoid the Mouse wheel event altogether. Just change the WndProc overridde to the code below, and mouse wheel events will be ignored.

protected override void WndProc(ref Message message)
{
    //avoid mouse wheel events
    if (message.Msg != WM_MOUSEWHEEL)
        base.WndProc(ref message);
}

Overriding WndProc gives you a lot of power and control over what happens in your application. This particular (very limited) example handles MouseWheel events on a ComboBox, but you can really use this to do a lot of very powerful stuff, like disabling the keyboard or parts of it, routing messages to other controls, broadcasting messages to have several controls react to the same message, etc. etc.

• Write a dummy text file on startup, and check the existance of this file.
• Write to a registry-key on startup, and use that as a “mutex”.
• Use a named mutex with a system-wide scope.

Obviously the first two have the problem that they may break the program, if the program exits without resetting the file/registry-key used as a pseudo-mutex. They are also very crude and not very elegant…. But that’s up to personal taste i guess.
I went for the third choice; The named mutex.

The named mutex in Windows CE

The .NET Compact Framework does not support named mutexes. Luckily Windows CE does however, and it can be imported through a few functions in coredll.dll.
A named mutex is an object created by the OS with a name specified on creation. The actual functionality of the object is not very interesting right now. The interesting bit is that only one object can exist with any given name. If you try to create another object with the same name, you get an error.
Basically, if you create a named mutex with the name of the application itself, this can be used to ensure that only one instance of the application can be run.

Wrapping it up

I decided to wrap it all up nicely in a class, so that it will be easy to use. The class is called SingleInstanceApplication, and here is what i came up with:

using System;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using System.Reflection;

namespace Bitmatic
{
  static class SingleInstanceApplication
  {
    [DllImport("coredll.dll", SetLastError = true)]
    public static extern IntPtr CreateMutex(IntPtr Attr, bool Own, string Name);

    [DllImport("coredll.dll", SetLastError = true)]
    public static extern bool ReleaseMutex(IntPtr hMutex);

    const long ERROR_ALREADY_EXISTS = 183;

    public static void Run(Form frm)
    {
      string name = Assembly.GetExecutingAssembly().GetName().Name;
      IntPtr mutexHandle = CreateMutex(IntPtr.Zero, true, name);
      long error = Marshal.GetLastWin32Error();

      if (error != ERROR_ALREADY_EXISTS)
        Application.Run(frm);

      ReleaseMutex(mutexHandle);
    }
  }
}

Feel free to steal….
The class imports the two native functions for creating and destroying mutexes, and has only a single public function.
The Run function tries to create a mutex with the name of the application. It then checks the error code returned, to see if the mutex already exists, and if it doesn’t; starts the application. Finally it releases the mutex.
Very simple, and quite a bit more elegant than the file/registry based solutions.

Using it

Using the class is very very simple. Just add the class itself to your project, open up Program.cs and replace:

[MTAThread]
static void Main()
{
  Application.Run(new Form1());
}

with:

[MTAThread]
static void Main()
{
  SingleInstanceApplication.Run(new Form1());
}

You only really changed one line, and now you have an application that is guaranteed to run only as a single instance.

The ScrollingRichTextBox

A far more elegant solution is to use the underlying message system to control the scroll. Using the SendMessage function it is possible to send a WM_VSCROLL message to the control that makes the control scroll without needing to worry about focus.
I think the best solution is to make a small class that inherits from RichTextBox, and neatly wraps the SendMessage calls necessary to make it work. Many programmers are unfamiliar with the syntax involved, so wrapping it in a more familiar syntax is a good idea.

The complete class looks like this:

class ScrollingRichTextBox : System.Windows.Forms.RichTextBox
{
  [DllImport("user32.dll", CharSet = CharSet.Auto)]
  private static extern IntPtr SendMessage(
    IntPtr hWnd,
    uint Msg,
    IntPtr wParam,
    IntPtr lParam);

  private const int WM_VSCROLL = 277;
  private const int SB_LINEUP = 0;
  private const int SB_LINEDOWN = 1;
  private const int SB_TOP = 6;
  private const int SB_BOTTOM = 7;

  public void ScrollToBottom()
  {
    SendMessage(Handle, WM_VSCROLL, new IntPtr(SB_BOTTOM), new IntPtr(0));
  }

  public void ScrollToTop()
  {
    SendMessage(Handle, WM_VSCROLL, new IntPtr(SB_TOP), new IntPtr(0));
  }

  public void ScrollLineDown()
  {
    SendMessage(Handle, WM_VSCROLL, new IntPtr(SB_LINEDOWN), new IntPtr(0));
  }

  public void ScrollLineUp()
  {
    SendMessage(Handle, WM_VSCROLL, new IntPtr(SB_LINEUP), new IntPtr(0));
  }
}

Feel free to steal…

How it works

The class imports the SendMessage function from the user32.dll system library. I’m not gonna go deeply into that function in this post. It is insanely powerfull and deserves it’s own post someday. It allows the program to send native windows messages to the control. The message in play here is the WM_VSCROLL message that takes a parameter that tells it how to scroll. These parameters are constants that are defined in the winuser.h header file.

I have implemented four functions in this class, allowing it to scroll to the top and bottom, as well as a single line up and down.

With the SendMessage function imported and using winuser.h as a reference you could easily implement even more functionality in the class, such as pageup/pagedown (SB_PAGEUP/SB_PAGEDOWN), but i don’t want to bloat the class with that for this article. The principle is what counts here.

A simple usage example

For applications that require this sort of scrolling, using the ScrollingRichTextBox over the ordinary RichTextBox is the way to go. In a previous blog post, i talked about hooking up to the OnTextChanged event of a RichTextBox and using ScrollToCaret() to do the scrolling. A method that has a few issues.
Now, using the ScrollingRichTextBox, these issues are resolved and the complete code for that event looks like this:

private void scrollingRichTextBox_TextChanged(object sender, EventArgs e)
{
  scrollingRichTextBox.ScrollToBottom();
}

Neat huh?