.NET FOLLOWER

     Recently I needed to hide the checkboxes of some nodes in a TreeView-control, i.e. some nodes should be checkable, but the rest shouldn’t.

Standard TreeView doesn’t allow to do that directly, but Windows API will help us out. The main idea is to catch the moment when a node is just added, then to examine whether checkbox of the node must be hidden and, if yes, to send a certain TVM_SETITEM message to the control to hide checkbox.

Unfortunately, TreeView-control doesn’t provide with an event, which could be fired after a node is added. That is why we have to work with WinAPI messages directly inside WndProc.

By means of Reflector I’ve found out that when a node is being added to Nodes-collection of a TreeView or another node the following code is running (these lines from the internal method Realize of TreeNode class):

this.handle = UnsafeNativeMethods.SendMessage(new HandleRef(this.TreeView, this.TreeView.Handle), NativeMethods.TVM_INSERTITEM, 0, ref lParam);
treeView.nodeTable[this.handle] = this;
this.UpdateNode(4);

After the first line passed the parent TreeView-control receives TVM_INSERTITEM message. We would catch this message inside WndProc of TreeView-control and get the handle of added node, however on this stage we wouldn’t be able to find the TreeNode-object, which corresponds to the handle. But we need TreeNode-object in order to examine whether its checkbox must be hidden.
Just after the second line the hashtable nodeTable of TreeView-control already contains information which TreeNode-object is linked to the added node handle. But TVM_INSERTITEM has already been processed. That means we have to catch another type of messages.
Luckily, inside the method UpdateNode from the third line the TVM_SETITEM message is sent to the parent TreeView-control. I decided to catch this kind of messages to have ability to hide checkbox of just added node, if it’s required.

The descendants of TreeView-control and TreeNode, those embody this approach, are presented below

/// <summary>
/// Allows to detect nodes, the checkbox of those must be hidden
/// </summary>
public class HiddenCheckBoxTreeNode : TreeNode
{
    internal bool CheckboxHidden { set; get; }

    public    HiddenCheckBoxTreeNode() {}
    public    HiddenCheckBoxTreeNode(string text) : base(text) {}
    public    HiddenCheckBoxTreeNode(string text, TreeNode[] children) : base(text, children) {}
    public    HiddenCheckBoxTreeNode(string text, int imageIndex, int selectedImageIndex) : base(text, imageIndex, selectedImageIndex) {}
    public    HiddenCheckBoxTreeNode(string text, int imageIndex, int selectedImageIndex, TreeNode[] children) : base(text, imageIndex, selectedImageIndex, children) {}
    protected HiddenCheckBoxTreeNode(SerializationInfo serializationInfo, StreamingContext context) : base(serializationInfo, context) { }
}    

public class MixedCheckBoxesTreeView : TreeView
{
    /// <summary>
    /// Specifies or receives attributes of a node
    /// </summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
    public struct TV_ITEM
    {
        public int    Mask;
        public IntPtr ItemHandle;
        public int    State;
        public int    StateMask;
        public IntPtr TextPtr;
        public int    TextMax;
        public int    Image;
        public int    SelectedImage;
        public int    Children;
        public IntPtr LParam;
    }

    public const int TVIF_STATE          = 0x8;
    public const int TVIS_STATEIMAGEMASK = 0xF000;

    public const int TVM_SETITEMA = 0x110d;
    public const int TVM_SETITEM  = 0x110d;
    public const int TVM_SETITEMW = 0x113f;

    [DllImport("user32.dll", CharSet = CharSet.Auto)]
    public static extern IntPtr SendMessage(HandleRef hWnd, int msg, int wParam, ref TV_ITEM lParam);

    protected override void WndProc(ref Message m)
    {
        base.WndProc(ref m);

        // trap TVM_SETITEM message
        if (m.Msg == TVM_SETITEM || m.Msg == TVM_SETITEMA || m.Msg == TVM_SETITEMW)
            // check if CheckBoxes are turned on
            if (CheckBoxes)
            {
                // get information about the node
                TV_ITEM tv_item = (TV_ITEM)m.GetLParam(typeof(TV_ITEM));
                HideCheckBox(tv_item);
            }
    }    

    protected void HideCheckBox(TV_ITEM tv_item)
    {
        if (tv_item.ItemHandle != IntPtr.Zero)
        {
            // get TreeNode-object, that corresponds to TV_ITEM-object
            TreeNode currentTN = TreeNode.FromHandle(this, tv_item.ItemHandle);

            HiddenCheckBoxTreeNode hiddenCheckBoxTreeNode = currentTN as HiddenCheckBoxTreeNode;
            // check if it's HiddenCheckBoxTreeNode and
            // if its checkbox already has been hidden
            if (hiddenCheckBoxTreeNode != null && !hiddenCheckBoxTreeNode.CheckboxHidden)
            {
                // to evade repeat hiding, we set CheckboxHidden to  true
                hiddenCheckBoxTreeNode.CheckboxHidden = true;                

                // specify attributes to update
                TV_ITEM updatedTvItem    = new TV_ITEM();
                updatedTvItem.ItemHandle = tv_item.ItemHandle;
                updatedTvItem.Mask       = TVIF_STATE;
                updatedTvItem.StateMask  = TVIS_STATEIMAGEMASK;
                updatedTvItem.State      = 0;

                // send TVM_SETITEM message
                SendMessage(new HandleRef(this, Handle), TVM_SETITEM, 0, ref updatedTvItem);
            }
        }
    }

    protected override void OnBeforeCheck(TreeViewCancelEventArgs e)
    {
        base.OnBeforeCheck(e);

        // prevent checking/unchecking of HiddenCheckBoxTreeNode,
        // otherwise, we will have to repeat checkbox hiding
        if (e.Node is HiddenCheckBoxTreeNode)
            e.Cancel = true;
    }
}

Also we need to ban an ability to change the property Checked of TreeNode-object, because if it has happened, we would have to hide checkbox again. Method OnBeforeCheck does it.

Below the sample of usage of these classes:

// put the MixedCheckBoxesTreeView on the form and override OnLoad method of the form
protected override void OnLoad(EventArgs e)
{
    base.OnLoad(e);

    mixedCheckBoxesTreeView1.CheckBoxes = true;
    mixedCheckBoxesTreeView1.Nodes.Clear();

    HiddenCheckBoxTreeNode tn = new HiddenCheckBoxTreeNode("Root Node 1");
    mixedCheckBoxesTreeView1.Nodes.Add(tn);

    TreeNode tn2 = new TreeNode("Child Node A");
    tn.Nodes.Add(tn2);

    HiddenCheckBoxTreeNode tn3 = new HiddenCheckBoxTreeNode("Child Node B");
    tn3.Checked = true; // just to test that nothing happens here
    tn.Nodes.Add(tn3);

    HiddenCheckBoxTreeNode tn4 = new HiddenCheckBoxTreeNode("Child Node C");
    tn.Nodes.Add(tn4);

    TreeNode tn5 = new TreeNode("Child Node D");
    tn.Nodes.Add(tn5);

    TreeNode tn6 = new TreeNode("Root Node 2");
    mixedCheckBoxesTreeView1.Nodes.Add(tn6);

    TreeNode tn7 = new TreeNode("Root Node 3");
    mixedCheckBoxesTreeView1.Nodes.Add(tn7);

    HiddenCheckBoxTreeNode tn8 = new HiddenCheckBoxTreeNode("Child Node A");
    tn7.Nodes.Add(tn8);

    mixedCheckBoxesTreeView1.ExpandAll();
}

Related posts:

• WinForms: Show individual tooltip for each ListBox item
• WinForms: Show progress on long-running operations