.NET Compact Framework Team : Author: Tim Gerken

Subclassing controls in .NETCF 2.0, part 2

NetCFTeam — Tue, 24 May 2005 00:10:00 GMT

Last time, we introduced the WndProcHooker class to facilitate hooking windows messages for managed controls at the native WndProc level. This time, we will use that WndProcHooker class to extend the .NETCF supplied TreeView control and add the NodeMouseClicked event.

caveat: You will need to have a post-beta2 build of the .NET Compact Framework for this sample to compile and work properly. The TreeNode class in the beta2 build did not have the Handle property used by this sample. Any .NETCF build after 2.00.5133.00 will suffice.

First off, here is the extended TreeView Class:

using System;
using System.Drawing;
using System.Windows.Forms;

namespace SubclassSample
{
    /// <summary>
    /// Extends the standard TreeView control to add an implementation
    /// of the NodeMouseClick event.
    /// </summary>
    public partial class TreeViewBonus : TreeView
    {
        /// <summary>
        /// The original parent of this control.
        /// </summary>
        Control prevParent = null;

        /// <summary>
        /// Creates a new instance of the derived TreeView control
        /// </summary>
        public TreeViewBonus()
        {
            InitializeComponent();
        }

        /// <summary>
        /// Called when the control's parent is changed. Here we hook into that
        /// parent's WndProc and spy on the WM_NOTIFY message. When the parent
        /// changes, we unhook the old parent's WndProc and hook into the new one.
        /// </summary>
        /// <param name="e">The arguments for this event</param>
        protected override void OnParentChanged(EventArgs e)
        {
            // unhook the old parent
            if (this.prevParent != null)
            {
                WndProcHooker.UnhookWndProc(prevParent, Win32.WM_NOTIFY);
            }
            // update the previous parent
            prevParent = this.Parent;

            // hook up the new parent
            if (this.Parent != null)
            {
                WndProcHooker.HookWndProc(this.Parent,
                    new WndProcHooker.WndProcCallback(this.WM_Notify_Handler),
                    Win32.WM_NOTIFY);
            }

            base.OnParentChanged(e);
        }

        /// <summary>
        /// Occurs when the user clicks a TreeNode with the mouse.
        /// </summary>
        public event TreeNodeMouseClickEventHandler NodeMouseClick;

        /// <summary>
        /// Occurs when the mouse pointer is over the control and a mouse button is clicked.
        /// </summary>
        /// <param name="e">Provides data for the NodeMouseClick event.</param>
        protected void OnNodeMouseClick(TreeNodeMouseClickEventArgs e)
        {
            if (NodeMouseClick != null)
                NodeMouseClick(this, e);
        }

        /// <summary>
        /// The method that gets called when a WM_NOTIFY message is received by the
        /// TreeView's parent.
        /// </summary>
        /// <param name="hwnd">The handle of the window that received the message</param>
        /// <param name="msg">The message received</param>
        /// <param name="wParam">The wParam arguments for the message</param>
        /// <param name="lParam">The lParam arguments for the message</param>
        /// <param name="handled">Set to true to indicate that this message was handled</param>
        /// <returns>An appropriate returen code for the message handled (see MSDN)</returns>
        int WM_Notify_Handler(
            IntPtr hwnd, uint msg, uint wParam, int lParam,
            ref bool handled)
        {
            Win32.NMHDR nmHdr = new Win32.NMHDR();
            System.Runtime.InteropServices.Marshal.PtrToStructure((IntPtr)lParam, nmHdr);
            switch (nmHdr.code)
            {
                case Win32.NM_RCLICK:
                case Win32.NM_CLICK:
                    // get the cursor coordinates on the client
                    Point msgPos = Win32.LParamToPoint((int)Win32.GetMessagePos());
                    msgPos = this.PointToClient(msgPos);

                    // check to see if the click was on an item
                    Win32.TVHITTESTINFO hti = new Win32.TVHITTESTINFO();
                    hti.pt.X = msgPos.X;
                    hti.pt.Y = msgPos.Y;
                    int hitem = Win32.SendMessage(this.Handle, Win32.TVM_HITTEST, 0, ref hti);
                    uint htMask = (
                        Win32.TVHT_ONITEMICON |
                        Win32.TVHT_ONITEMLABEL |
                        Win32.TVHT_ONITEMINDENT |
                        Win32.TVHT_ONITEMBUTTON |
                        Win32.TVHT_ONITEMRIGHT |
                        Win32.TVHT_ONITEMSTATEICON);
                    if ((hti.flags & htMask) != 0)
                    {
                        bool leftButton = (nmHdr.code == Win32.NM_CLICK);
                        RaiseNodeMouseClickEvent(hti.hItem,
                            leftButton ? MouseButtons.Left : MouseButtons.Right,
                            msgPos);
                        return 0;
                    }
                    break;

                default:
                    break;
            }
            return 0;
        }

        /// <summary>
        /// Raises the TreeNodeMouseClick event for the TreeNode with the specified handle.
        /// </summary>
        /// <param name="hNode">The handle of the node for which the event is raised</param>
        /// <param name="button">The [mouse] buttons that were pressed to raise the event</param>
        /// <param name="coords">The [client] cursor coordinates at the time of the event</param>
        void RaiseNodeMouseClickEvent(IntPtr hNode, MouseButtons button, Point coords)
        {
            TreeNode tn = FindTreeNodeFromHandle(this.Nodes, hNode);

            TreeNodeMouseClickEventArgs e = new TreeNodeMouseClickEventArgs(
                tn,
                button,
                1, coords.X, coords.Y);

            OnNodeMouseClick(e);
        }

        /// <summary>
        /// Finds a TreeNode in the provided TreeNodeCollection that has the handle specified.
        /// Warning: recursion!
        /// </summary>
        /// <param name="tnc">The TreeNodeCollection to search</param>
        /// <param name="handle">The handle of the TreeNode to find in the collection</param>
        /// <returns>The TreeNode if found; null otherwise</returns>
        TreeNode FindTreeNodeFromHandle(TreeNodeCollection tnc, IntPtr handle)
        {
            foreach (TreeNode tn in tnc)
            {
                if (tn.Handle == handle) return tn;
                // we couldn't have clicked on a child of this node if this node
                // is not expanded!
                if (tn.IsExpanded)
                {
                    TreeNode tn2 = FindTreeNodeFromHandle(tn.Nodes, handle);
                    if (tn2 != null) return tn2;
                }
            }
            return null;
        }
    }
}

Note, we need to add the TreeNodeMouseClickEventHandler and TreeNodeMouseClickEventArgs classes under System.Windows.Forms.

namespace System.Windows.Forms
{
    /// <summary>
    /// Represents the method that will handle the NodeMouseClick event of a TreeView
    /// </summary>
    /// <param name="sender">The source of the event.</param>
    /// <param name="e">A TreeNodeMouseClickEventArgs that contains the event data.</param>
    public delegate void TreeNodeMouseClickEventHandler(object sender, TreeNodeMouseClickEventArgs e);

    /// <summary>
    /// Provides data for the System.Windows.Forms.TreeView.NodeMouseClick event
    /// </summary>
    public class TreeNodeMouseClickEventArgs : MouseEventArgs
    {
        /// <summary>
        /// Initializes a new instance of the TreeNodeMouseClickEventArgs class.
        /// </summary>
        /// <param name="node">The node that was clicked</param>
        /// <param name="button">One of the System.Windows.Forms.MouseButtons members</param>
        /// <param name="clicks">The number of clicks that occurred</param>
        /// <param name="x">The x-coordinate where the click occurred</param>
        /// <param name="y">The y-coordinate where the click occurred</param>
        public TreeNodeMouseClickEventArgs(TreeNode node, MouseButtons button, int clicks, int x, int y) :
            base(button, clicks, x, y, 0)
        {
            nodeValue = node;
        }

        /// <summary>
        /// Gets the node that was clicked.
        /// </summary>
        public TreeNode Node
        {
            get { return nodeValue; }
            set { nodeValue = value; }
        }
        TreeNode nodeValue;

        public override string ToString()
        {
            return string.Format(
                "TreeNodeMouseClickEventArgs\r\n\tNode: {0}\r\n\tButton: {1}\r\n\tX: {2}\r\n\tY: {3}",
                nodeValue.Text, Button.ToString(), X, Y);
        }
    }
}

Lastly, here are the Win32 constants, structures and such that need to be defined. Add these to the Win32 class defined yesterday.

public const uint WM_NOTIFY = 0x4E;

    public const uint NM_CLICK = 0xFFFFFFFE;
    public const uint NM_RCLICK = 0xFFFFFFFB;

    public const uint TV_FIRST = 0x1100;
    public const uint TVM_HITTEST = TV_FIRST + 17;

    public const uint TVHT_NOWHERE = 0x0001;
    public const uint TVHT_ONITEMICON = 0x0002;
    public const uint TVHT_ONITEMLABEL = 0x0004;
    public const uint TVHT_ONITEM = (TVHT_ONITEMICON | TVHT_ONITEMLABEL | TVHT_ONITEMSTATEICON);
    public const uint TVHT_ONITEMINDENT = 0x0008;
    public const uint TVHT_ONITEMBUTTON = 0x0010;
    public const uint TVHT_ONITEMRIGHT = 0x0020;
    public const uint TVHT_ONITEMSTATEICON = 0x0040;
    public const uint TVHT_ABOVE = 0x0100;
    public const uint TVHT_BELOW = 0x0200;
    public const uint TVHT_TORIGHT = 0x0400;
    public const uint TVHT_TOLEFT = 0x0800;

    [System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]
    public class NMHDR
    {
        public IntPtr hwndFrom;
        public uint idFrom;
        public uint code;
    }

    public struct TVHITTESTINFO
    {
        public POINT pt;
        public uint flags;
        public IntPtr hItem;
    }

    /// <summary>
    /// Helper function to convert a Windows lParam into a Point
    /// </summary>
    /// <param name="lParam">The parameter to convert</param>
    /// <returns>A Point where X is the low 16 bits and Y is the
    /// high 16 bits of the value passed in</returns>
    public static Point LParamToPoint(int lParam)
    {
        uint ulParam = (uint)lParam;
        return new Point(
            (int)(ulParam & 0x0000ffff),
            (int)((ulParam & 0xffff0000) >> 16));
    }

#if DESKTOP
    [DllImport("user32.dll")]
#else
    [DllImport("coredll.dll")]
#endif
    public extern static uint GetMessagePos();

#if DESKTOP
    [DllImport("user32.dll")]
#else
    [DllImport("coredll.dll")]
#endif
    public extern static int SendMessage(
        IntPtr hwnd, uint msg, uint wParam, ref TVHITTESTINFO lParam);

The original incarnation of this sample was to extend the Button class and give the button a GradientFill for its background. As it turned out, that sample was far too complex for what I was trying to demonstrate. Since the native button class appears to render its state in a double-buffered fashion, I couldn't just hook the WM_ERASEBKGND message, draw the background and let the button do the rest. No, I needed to hook WM_PAINT, WM_LBUTTONDOWN, WM_LBUTTONUP, WM_MOUSEMOVE, WM_KEYDOWN and WM_KEYUP and render the button as appropriate for the message and the button's state. As it turns out, it is a lot easier to just extend System.Windows.Forms.Control and make your fancy buttons from there.

The other interesting thing that came out of this sample is this note on performance. In the original implementation of WndProcHooker.WindowProc from yesterday, I wasn't making use of the Contains() method on the hwndDict object. Instead, I was just calling the indexer directly and catching and eating the KeyNotFoundException. The performance of the sample was so bad I was considering scraping it altogether until my friend Chris pointed out just how many messages were going through that WindowProc method. Transitioning between native and managed code for every message is expensive, but throwing and catching (and ignoring!) an exception for 99% of them is outrageous.

That's it for now.

Tim

This posting is provided "AS IS" with no warranties, and confers no rights.

Subclassing controls in .NETCF 2.0, part 1

NetCFTeam — Fri, 20 May 2005 22:34:00 GMT

The .NET Compact Framework is just that. It is compact. We have to make tradeoffs between functionality and size. Sometimes, developers want more than we provide in the box. In our v1 product we didn't expose the Handle property on Control. It made it very difficult for developers to do the sort of customization they wanted to do. In addition, we didn't provide a way for native code to call into managed code via a delegate.

On v2, we have fixed those issues. We still don't provide all of the properties, methods and events that our desktop counterpart does. We're the Compact framework, right? By calling down into native code, however, we can use some of the Win32 API to extend some of the provided .NETCF controls. The code provided today will lay the groundwork for the next post where we will add a "missing" event to the TreeView control.

That said, here is the "WndProcHooker" class that is the main "guts" to this sample.

using System; using System.Collections; using System.Collections.Generic; using System.Runtime.InteropServices; using System.Text; using System.Windows.Forms; namespace SubclassSample { class WndProcHooker { /// <summary> /// The callback used when a hooked window's message map contains the /// hooked message /// </summary> /// <param name="hwnd">The handle to the window for which the message /// was received</param> /// <param name="wParam">The message's parameters (part 1)</param> /// <param name="lParam">The message's parameters (part 2)</param> /// <param name="handled">The invoked function sets this to true if it /// handled the message. If the value is false when the callback /// returns, the next window procedure in the wndproc chain is /// called</param> /// <returns>A value specified for the given message in the MSDN /// documentation</returns> public delegate int WndProcCallback( IntPtr hwnd, uint msg, uint wParam, int lParam, ref bool handled); /// <summary> /// This is the global list of all the window procedures we have /// hooked. The key is an hwnd. The value is a HookedProcInformation /// object which contains a pointer to the old wndproc and a map of /// messages/callbacks for the window specified. Controls whose handles /// have been created go into this dictionary. /// </summary> private static Dictionary<IntPtr, HookedProcInformation> hwndDict = new Dictionary<IntPtr, HookedProcInformation>(); /// <summary> /// See <see>hwndDict</see>. The key is a control and the value is a /// HookedProcInformation. Controls whose handles have not been created /// go into this dictionary. When the HandleCreated event for the /// control is fired the control is moved into <see>hwndDict</see>. /// </summary> private static Dictionary<Control, HookedProcInformation> ctlDict = new Dictionary<Control, HookedProcInformation>(); /// <summary> /// Makes a connection between a message on a specified window handle /// and the callback to be called when that message is received. If the /// window was not previously hooked it is added to the global list of /// all the window procedures hooked. /// </summary> /// <param name="ctl">The control whose wndproc we are hooking</param> /// <param name="callback">The method to call when the specified /// message is received for the specified window</param> /// <param name="msg">The message we are hooking.</param> public static void HookWndProc( Control ctl, WndProcCallback callback, uint msg) { HookedProcInformation hpi = null; if (ctlDict.ContainsKey(ctl)) hpi = ctlDict[ctl]; else if (hwndDict.ContainsKey(ctl.Handle)) hpi = hwndDict[ctl.Handle]; if (hpi == null) { // We havne't seen this control before. Create a new // HookedProcInformation for it hpi = new HookedProcInformation(ctl, new Win32.WndProc(WndProcHooker.WindowProc)); ctl.HandleCreated += new EventHandler(ctl_HandleCreated); ctl.HandleDestroyed += new EventHandler(ctl_HandleDestroyed); ctl.Disposed += new EventHandler(ctl_Disposed); // If the handle has already been created set the hook. If it // hasn't been created yet, the hook will get set in the // ctl_HandleCreated event handler if (ctl.Handle != IntPtr.Zero) hpi.SetHook(); } // stick hpi into the correct dictionary if (ctl.Handle == IntPtr.Zero) ctlDict[ctl] = hpi; else hwndDict[ctl.Handle] = hpi; // add the message/callback into the message map hpi.messageMap[msg] = callback; } /// <summary> /// The event handler called when a control is disposed. /// </summary> /// <param name="sender">The object that raised this event</param> /// <param name="e">The arguments for this event</param> static void ctl_Disposed(object sender, EventArgs e) { Control ctl = sender as Control; if (ctlDict.ContainsKey(ctl)) ctlDict.Remove(ctl); else System.Diagnostics.Debug.Assert(false); } /// <summary> /// The event handler called when a control's handle is destroyed. /// We remove the HookedProcInformation from <see>hwndDict</see> and /// put it back into <see>ctlDict</see> in case the control get re- /// created and we still want to hook its messages. /// </summary> /// <param name="sender">The object that raised this event</param> /// <param name="e">The arguments for this event</param> static void ctl_HandleDestroyed(object sender, EventArgs e) { // When the handle for a control is destroyed, we want to // unhook its wndproc and update our lists Control ctl = sender as Control; if (hwndDict.ContainsKey(ctl.Handle)) { HookedProcInformation hpi = hwndDict[ctl.Handle]; UnhookWndProc(ctl, false); } else System.Diagnostics.Debug.Assert(false); } /// <summary> /// The event handler called when a control's handle is created. We /// call SetHook() on the associated HookedProcInformation object and /// move it from <see>ctlDict</see> to <see>hwndDict</see>. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> static void ctl_HandleCreated(object sender, EventArgs e) { Control ctl = sender as Control; if (ctlDict.ContainsKey(ctl)) { HookedProcInformation hpi = ctlDict[ctl]; hwndDict[ctl.Handle] = hpi; ctlDict.Remove(ctl); hpi.SetHook(); } else System.Diagnostics.Debug.Assert(false); } /// <summary> /// This is a generic wndproc. It is the callback for all hooked /// windows. If we get into this function, we look up the hwnd in the /// global list of all hooked windows to get its message map. If the /// message received is present in the message map, its callback is /// invoked with the parameters listed here. /// </summary> /// <param name="hwnd">The handle to the window that received the /// message</param> /// <param name="msg">The message</param> /// <param name="wParam">The message's parameters (part 1)</param> /// <param name="lParam">The messages's parameters (part 2)</param> /// <returns>If the callback handled the message, the callback's return /// value is returned form this function. If the callback didn't handle /// the message, the message is forwarded on to the previous wndproc. /// </returns> private static int WindowProc( IntPtr hwnd, uint msg, uint wParam, int lParam) { if (hwndDict.ContainsKey(hwnd)) { HookedProcInformation hpi = hwndDict[hwnd]; if (hpi.messageMap.ContainsKey(msg)) { WndProcCallback callback = hpi.messageMap[msg]; bool handled = false; int retval = callback(hwnd, msg, wParam, lParam, ref handled); if (handled) return retval; } // if we didn't hook the message passed or we did, but the // callback didn't set the handled property to true, call // the original window procedure return hpi.CallOldWindowProc(hwnd, msg, wParam, lParam); } System.Diagnostics.Debug.Assert( false, "WindowProc called for hwnd we don't know about"); return Win32.DefWindowProc(hwnd, msg, wParam, lParam); } /// <summary> /// This method removes the specified message from the message map for /// the specified hwnd. /// </summary> /// <param name="ctl">The control whose message we are unhooking /// </param> /// <param name="msg">The message no longer want to hook</param> public static void UnhookWndProc(Control ctl, uint msg) { // look for the HookedProcInformation in the control and hwnd // dictionaries HookedProcInformation hpi = null; if (ctlDict.ContainsKey(ctl)) hpi = ctlDict[ctl]; else if (hwndDict.ContainsKey(ctl.Handle)) hpi = hwndDict[ctl.Handle]; // if we couldn't find a HookedProcInformation, throw if (hpi == null) throw new ArgumentException("No hook exists for this control"); // look for the message we are removing in the messageMap if (hpi.messageMap.ContainsKey(msg)) hpi.messageMap.Remove(msg); else // if we couldn't find the message, throw throw new ArgumentException( string.Format( "No hook exists for message ({0}) on this control", msg)); } /// <summary> /// Restores the previous wndproc for the specified window. /// </summary> /// <param name="ctl">The control whose wndproc we no longer want to /// hook</param> /// <param name="disposing">if true we remove don't readd the /// HookedProcInformation /// back into ctlDict</param> public static void UnhookWndProc(Control ctl, bool disposing) { HookedProcInformation hpi = null; if (ctlDict.ContainsKey(ctl)) hpi = ctlDict[ctl]; else if (hwndDict.ContainsKey(ctl.Handle)) hpi = hwndDict[ctl.Handle]; if (hpi == null) throw new ArgumentException("No hook exists for this control"); // If we found our HookedProcInformation in ctlDict and we are // disposing remove it from ctlDict if (ctlDict.ContainsKey(ctl) && disposing) ctlDict.Remove(ctl); // If we found our HookedProcInformation in hwndDict, remove it // and if we are not disposing stick it in ctlDict if (hwndDict.ContainsKey(ctl.Handle)) { hpi.Unhook(); hwndDict.Remove(ctl.Handle); if (!disposing) ctlDict[ctl] = hpi; } } /// <summary> /// This class remembers the old window procedure for the specified /// window handle and also provides the message map for the messages /// hooked on that window. /// </summary> class HookedProcInformation { /// <summary> /// The message map for the window /// </summary> public Dictionary<uint, WndProcCallback> messageMap; /// <summary> /// The old window procedure for the window /// </summary> private IntPtr oldWndProc; /// <summary> /// The delegate that gets called in place of this window's /// wndproc. /// </summary> private Win32.WndProc newWndProc; /// <summary> /// Control whose wndproc we are hooking /// </summary> private Control control; /// <summary> /// Constructs a new HookedProcInformation object /// </summary> /// <param name="ctl">The handle to the window being hooked</param> /// <param name="wndproc">The window procedure to replace the /// original one for the control</param> public HookedProcInformation(Control ctl, Win32.WndProc wndproc) { control = ctl; newWndProc = wndproc; messageMap = new Dictionary<uint, WndProcCallback>(); } /// <summary> /// Replaces the windows procedure for <see>control</see> with the /// one specified in the constructor. /// </summary> public void SetHook() { IntPtr hwnd = control.Handle; if (hwnd == IntPtr.Zero) throw new InvalidOperationException( "Handle for control has not been created"); oldWndProc = Win32.SetWindowLong(hwnd, Win32.GWL_WNDPROC, Marshal.GetFunctionPointerForDelegate(newWndProc)); } /// <summary> /// Restores the original window procedure for the control. /// </summary> public void Unhook() { IntPtr hwnd = control.Handle; if (hwnd == IntPtr.Zero) throw new InvalidOperationException( "Handle for control has not been created"); Win32.SetWindowLong(hwnd, Win32.GWL_WNDPROC, oldWndProc); } /// <summary> /// Calls the original window procedure of the control with the /// arguments provided. /// </summary> /// <param name="hwnd">The handle of the window that received the /// message</param> /// <param name="msg">The message</param> /// <param name="wParam">The message's arguments (part 1)</param> /// <param name="lParam">The message's arguments (part 2)</param> /// <returns>The value returned by the control's original wndproc /// </returns> public int CallOldWindowProc( IntPtr hwnd, uint msg, uint wParam, int lParam) { return Win32.CallWindowProc( oldWndProc, hwnd, msg, wParam, lParam); } } } }

Here are some of the PInvokes, structures and constants you will need for this sample. I include them all in the sealed class called Win32:

using System; using System.Drawing; using System.Runtime.InteropServices; /// <summary> /// Contains managed wrappers or implementations of Win32 structs, delegates, /// constants and PInvokes that are useful for this sample. /// /// See the documentation on MSDN for more information on the elements provided /// in this file. /// </summary> public sealed class Win32 { /// <summary> /// A callback to a Win32 window procedure (wndproc) /// </summary> /// <param name="hwnd">The handle of the window receiving a message</param> /// <param name="msg">The message</param> /// <param name="wParam">The message's parameters (part 1)</param> /// <param name="lParam">The message's parameters (part 2)</param> /// <returns>A integer as described for the given message in MSDN</returns> public delegate int WndProc(IntPtr hwnd, uint msg, uint wParam, int lParam); #if DESKTOP [DllImport("user32.dll")] #else [DllImport("coredll.dll")] #endif public extern static int DefWindowProc( IntPtr hwnd, uint msg, uint wParam, int lParam); #if DESKTOP [DllImport("user32.dll")] #else [DllImport("coredll.dll")] #endif public extern static IntPtr SetWindowLong( IntPtr hwnd, int nIndex, IntPtr dwNewLong); public const int GWL_WNDPROC = -4; #if DESKTOP [DllImport("user32.dll")] #else [DllImport("coredll.dll")] #endif public extern static int CallWindowProc( IntPtr lpPrevWndFunc, IntPtr hwnd, uint msg, uint wParam, int lParam); }

Next time we will use the WndProcHooker class to extend the .NETCF supplied TreeView control to add the NodeMouseClicked event.

That's it for now.
Tim

This posting is provided "AS IS" with no warranties, and confers no rights.