MultiselectTreeview.cs

   1 using System;
   2 using System.Collections;
   3 using System.Text;
   4 using System.Windows.Forms;
   5 using System.Drawing;
   6
   7 namespace Gitrdone
   8 {
   9     public class MultiselectTreeview : TreeView
  10     {
  11         protected ArrayList m_coll;
  12         protected TreeNode m_firstNode;
  13
  14         public ArrayList SelectedNodes
  15         {
  16             get
  17             {
  18                 return m_coll;
  19             }
  20             set
  21             {
  22                 removePaintFromNodes();
  23                 m_coll.Clear();
  24                 m_coll = value;
  25                 paintSelectedNodes();
  26             }
  27         }
  28
  29         protected override void OnAfterSelect(TreeViewEventArgs e)
  30         {
  31             // e.Node is the current node exposed by the base TreeView control
  32
  33             base.OnAfterSelect(e);
  34             removePaintFromNodes();
  35
  36             bool bControl = (ModifierKeys == Keys.Control);
  37             bool bShift = (ModifierKeys == Keys.Shift);
  38
  39             if (bControl)
  40             {
  41                 if (!m_coll.Contains(e.Node)) // new node ?
  42                 {
  43                     m_coll.Add(e.Node);
  44                 }
  45                 else  // not new, remove it from the collection
  46                 {
  47                     m_coll.Remove(e.Node);
  48                 }
  49             }
  50             else
  51             {
  52                 /*if (bShift)
  53                 {
  54                     Queue myQueue = new Queue();
  55
  56                     TreeNode uppernode = m_firstNode;
  57                     TreeNode bottomnode = e.Node;
  58
  59                     // case 1 : begin and end nodes are parent
  60                     bool bParent = isParent(m_firstNode, e.Node);
  61                     if (!bParent)
  62                     {
  63                         bParent = isParent(bottomnode, uppernode);
  64                         if (bParent) // swap nodes
  65                         {
  66                             TreeNode t = uppernode;
  67                             uppernode = bottomnode;
  68                             bottomnode = t;
  69                         }
  70                     }
  71                     if (bParent)
  72                     {
  73                         TreeNode n = bottomnode;
  74                         while (n != uppernode.Parent)
  75                         {
  76                             if (!m_coll.Contains(n)) // new node ?
  77                                 myQueue.Enqueue(n);
  78
  79                             n = n.Parent;
  80                         }
  81                     }
  82                     // case 2 : nor the begin nor the
  83                     // end node are descendant one another
  84                     else
  85                     {
  86                         // are they siblings ?
  87
  88                         if ((uppernode.Parent == null && bottomnode.Parent == null)
  89                               || (uppernode.Parent != null &&
  90                               uppernode.Parent.Nodes.Contains(bottomnode)))
  91                         {
  92                             int nIndexUpper = uppernode.Index;
  93                             int nIndexBottom = bottomnode.Index;
  94                             if (nIndexBottom < nIndexUpper) // reversed?
  95                             {
  96                                 TreeNode t = uppernode;
  97                                 uppernode = bottomnode;
  98                                 bottomnode = t;
  99                                 nIndexUpper = uppernode.Index;
 100                                 nIndexBottom = bottomnode.Index;
 101                             }
 102
 103                             TreeNode n = uppernode;
 104                             while (nIndexUpper <= nIndexBottom)
 105                             {
 106                                 if (!m_coll.Contains(n)) // new node ?
 107                                     myQueue.Enqueue(n);
 108
 109                                 n = n.NextNode;
 110
 111                                 nIndexUpper++;
 112                             } // end while
 113
 114                         }
 115                         else
 116                         {
 117                             if (!m_coll.Contains(uppernode))
 118                                 myQueue.Enqueue(uppernode);
 119                             if (!m_coll.Contains(bottomnode))
 120                                 myQueue.Enqueue(bottomnode);
 121                         }
 122
 123                     }
 124
 125                     m_coll.AddRange(myQueue);
 126
 127                     paintSelectedNodes();
 128                     // let us chain several SHIFTs if we like it
 129                     m_firstNode = e.Node;
 130
 131                 } // end if m_bShift
 132                 else */
 133                 {
 134                     // in the case of a simple click, just add this item
 135                     if (m_coll != null && m_coll.Count > 0)
 136                     {
 137                         m_coll.Clear();
 138                     }
 139                     m_coll.Add(e.Node);
 140                 }
 141             }
 142             removePaintFromNodes();
 143         }
 144
 145         protected bool isParent(TreeNode parentNode, TreeNode childNode)
 146         {
 147             if (parentNode == childNode)
 148                 return true;
 149
 150             TreeNode n = childNode;
 151             bool bFound = false;
 152             while (!bFound && n != null)
 153             {
 154                 n = n.Parent;
 155                 bFound = (n == parentNode);
 156             }
 157             return bFound;
 158         }
 159
 160
 161         protected void paintSelectedNodes()
 162         {
 163             foreach (TreeNode n in m_coll)
 164             {
 165                 n.BackColor = SystemColors.Highlight;
 166                 n.ForeColor = SystemColors.HighlightText;
 167             }
 168         }
 169
 170         protected void removePaintFromNodes()
 171         {
 172             if (m_coll.Count == 0) return;
 173
 174             TreeNode n0 = (TreeNode)m_coll[0];
 175             Color back = n0.TreeView.BackColor;
 176             Color fore = n0.TreeView.ForeColor;
 177
 178             foreach (TreeNode n in m_coll)
 179             {
 180                 n.BackColor = back;
 181                 n.ForeColor = fore;
 182             }
 183         }
 184     }
 185 }