Message control implementation.

priozersk — Sun, 30 Nov 2008 18:40:00 GMT

In my previous post I described some history associated with the subclassing technique on .NET CF and promised to you to show my latest implementation of the subclassing control - Message control (I understand that the word "control" in the name is a little bit misleading because it's not a windows Control, but a helper class). Besides the fact that it replaces the window procedure, the MessageControl class handles some more complicated scenarios. For example, very often you need to sublcass the control's parent (Form), but you can have more than one control on the Form. In this case you would be "stealing" the window procedure from one another. So what the MessageControl is doing - it's checking if the particular window has already been subclassed and makes sure that there's only one instance of the same window procedure is been subclassed. Take a look at the following method which is a part of the MessageControl class:

/// <summary>

/// Subclasses the window.

/// </summary>

/// <param name="messageHost">Instance of the class that implements IMessage</param>

/// <param name="handle">Handle of the window to subclass</param>

/// <returns>An instance of the MessageControl</returns>

public static MessageControl Subclass(IMessage messageHost, IntPtr handle)

{

MessageControl msgControl = null;

// Check if we already subclassed this window

if (handleList.Keys.Contains(handle))

{

// We already subclassed it. Retrieve the MessageControl

msgControl = handleList[handle];

if (messageHost is Control)

{

((Control)messageHost).HandleDestroyed +=

new EventHandler(messageHost_HandleDestroyed);

}

// Add the message host to array list

msgControl.AddHost(messageHost);

}

else // New window

{

// Create new instance of the MessageControl

msgControl = new MessageControl();

// Associate it with the handle

handleList[handle] = msgControl;

// Add message host to array list

msgControl.AddHost(messageHost);

// Subclass the window

msgControl.Subclass(handle);

}

return msgControl;

}

As you can see from the code above this method is a factory method that will return an instance of the MessageControl to the caller. It also accepts the IMessage interface as a parameter which looks like this:

public interface IMessage

{

void WndProc(ref Microsoft.WindowsCE.Forms.Message m);

}

So all what is required for a class to receive the messages is to implement the IMessage interface. I've also added a few extention methods to make subclassing a little bit more user friendly by adding the ControlExtention class that implements a few helper methods:

/// <summary>

/// Enables subclassing of the Control.

/// </summary>

/// <param name="control">An instance of the Control.</param>

public static void EnableSubclassing(this Control control)

{

IMessage messageHost = control as IMessage;

if (messageHost != null)

{

MessageControl.Subclass(messageHost, control.Handle);

}

/// <summary>

/// Enables subclassing of the parent of the Control.

/// </summary>

/// <param name="control">An instance of the Control.</param>

public static void EnableParentSubclassing(this Control control)

{

IMessage messageHost = control as IMessage;

if (messageHost != null)

{

// Check if the parent is not null

if (control.Parent != null)

{

MessageControl.Subclass(messageHost,

control.Parent.Handle);

}

else

{

throw new ArgumentException("Cannot subclass.

Parent is null");

}

So to demonstrate the usage of these classes I decided to re-vamp one of my old samples (which, by the way, has a bug - it doesn't check for CBN_DROPDOWN message). In this sample I showed how to add the DropDown event to the ComboBox. So I modified the code besides raising the DropDown event, to also raise DropDownClose event. Below is the full source for the ComboBoxDrop control:

public class ComboBoxDrop : ComboBox, IMessage

{

// Events

public event EventHandler DropDown;

public event EventHandler DropDownClosed;

#region constants

private const int WM_COMMAND = 0x111;

private const short CBN_DROPDOWN = 7;

private const short CBN_CLOSEUP = 8;

#endregion

public ComboBoxDrop()

{

// Hook up into ParentChanged event

this.ParentChanged += new EventHandler(ComboBoxDrop_ParentChanged);

}

void ComboBoxDrop_ParentChanged(object sender, EventArgs e)

{

if (this.Parent != null)

{

// Start subclassing of the parent

this.EnableParentSubclassing();

}

#region IMessage Members

public void WndProc(ref Message m)

{

if (m.Msg == WM_COMMAND)

{

// Make sure that's its our ComboBox

if (m.LParam == this.Handle)

{

if (GetHighOrder(m.WParam) == CBN_DROPDOWN)

{

if (DropDown != null)

{

// Raise the event

DropDown(this, null);

}

else if (GetHighOrder(m.WParam) == CBN_CLOSEUP)

{

if (DropDownClosed != null)

{

// Raise the event

DropDownClosed(this, null);

}

// Call to the default window procedure

this.DefaultWinProc(ref m);

}

#endregion

private short GetHighOrder(IntPtr value)

{

return (short)((value.ToInt32() >> 16) & 0xffff);

}

In the code above you can see that we start subclassing of the ComboBox's parent Form by calling to the extention method EnableParentSubclassing().

As usual you can find the source code for the MessageControl and other classes attached.

A Tale of the Message control.

priozersk — Thu, 27 Nov 2008 01:41:00 GMT

Long time ago, when Windows Mobile devices where called Pocket PC's, when the most popular hand held device had the name that was starting form the letter "I" (not the IPod dummy, it's IPAQ), when the only way to develop for these devices was to use eMbedded Visual Basic or C++, when developing for devices was my side business / hobby, I had created a subclassing control for eVB developers that was called MessageCE. (The internet still holds the white paper that I had written on its usage). It was a COM component that allowed to subclass forms and controls in eVB programs. Subclassing is a very old technique that windows developers have been using if the default behaviour of the controls would not fit the requirements and they would want to add new features or change the control's behaviour. The essense of this technique is to replace the original window procedure with your own and process the messages in your code. Fast forward a few years when the first beta of the .NET Compact Framework came out and I started playing with it. While trying to create my own HTML viewer control I discovered that there would not be any way for me to subclass the manually created control (the delegates as native callbacks were not supported at the time) and I started complaining about this defficiency on the Microsoft newsgroups devoted to .NET CF other developer forums. My feedback got noticed and I was contacted by the PM from .NET CF product group. She asked me if I would like to visit Redmond where the SDR would be hold for the partners to discuss the .NET CF and they wanted to show me some solution to the problem I raised on the newsgroups. When I arrived in building 20 at Microsoft campus I was shown a new addition to the CF - MessageWindow class and asked if it would fit my needs. It wasn't a perfect solution, but it could work. In a couple of hours I wipped up a native helper library that would do the actual control subclassing and would send the messages to the instance of the MessageWindow. This code subsequently has become a basis for the managed controls that I created and made available through my company's (Intelliprog, Inc) web site: HTMLViewer and RichInk controls.

The window subclassing has become much easier since .NET CF v2 had added the support for the delegates as native callbacks and I was able to create NativeWindow class that has become a part of the SDF afterwards. Tim Gerken from the CF team has created WndProcHooker class which was documented in MSDN later on.

So a few months ago while working on a demo for TechEd, I created a new version of the subclassing control - Message Control - that would utilize some of the capablities of C# 3.0 and make the control subclassing an easy and user friendly process. I also wanted to make the resulting code to be compatible with the desktop way of control subclassing - just override the WndProc on the derived class. In the next few posts I'll show you the code and a usage scenarios for the Message control.

Alex Yakhnin's Blog : Subclassing

Message control implementation.

A Tale of the Message control.