UI/MultiselectTreeview.cs

   1 //Widgit is free software; you can redistribute it and/or modify
   2 //it under the terms of the GNU General Public License as published by
   3 //the Free Software Foundation; either version 2 of the License, or
   4 //(at your option) any later version.
   5
   6 //Widgit is distributed in the hope that it will be useful,
   7 //but WITHOUT ANY WARRANTY; without even the implied warranty of
   8 //MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   9 //GNU General Public License for more details.
  10
  11 //You should have received a copy of the GNU General Public License
  12 //along with Widgit; if not, write to the Free Software
  13 //Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USAusing System;
  14
  15 using System;
  16 using System.Collections;
  17 using System.Text;
  18 using System.Windows.Forms;
  19 using System.Drawing;
  20
  21 namespace Widgit
  22 {
  23     public class MultiselectTreeview : TreeView
  24     {
  25         protected ArrayList m_coll;
  26         protected TreeNode m_firstNode;
  27
  28         public ArrayList SelectedNodes
  29         {
  30             get
  31             {
  32                 return m_coll;
  33             }
  34             set
  35             {
  36                 removePaintFromNodes();
  37                 m_coll.Clear();
  38                 m_coll = value;
  39                 paintSelectedNodes();
  40             }
  41         }
  42
  43         protected override void OnAfterSelect(TreeViewEventArgs e)
  44         {
  45             // e.Node is the current node exposed by the base TreeView control
  46
  47             base.OnAfterSelect(e);
  48             removePaintFromNodes();
  49
  50             bool bControl = (ModifierKeys == Keys.Control);
  51             //bool bShift = (ModifierKeys == Keys.Shift);
  52
  53             if (bControl)
  54             {
  55                 if (!m_coll.Contains(e.Node)) // new node ?
  56                 {
  57                     m_coll.Add(e.Node);
  58                 }
  59                 else  // not new, remove it from the collection
  60                 {
  61                     m_coll.Remove(e.Node);
  62                 }
  63             }
  64             else
  65             {
  66                 /*if (bShift)
  67                 {
  68                     Queue myQueue = new Queue();
  69
  70                     TreeNode uppernode = m_firstNode;
  71                     TreeNode bottomnode = e.Node;
  72
  73                     // case 1 : begin and end nodes are parent
  74                     bool bParent = isParent(m_firstNode, e.Node);
  75                     if (!bParent)
  76                     {
  77                         bParent = isParent(bottomnode, uppernode);
  78                         if (bParent) // swap nodes
  79                         {
  80                             TreeNode t = uppernode;
  81                             uppernode = bottomnode;
  82                             bottomnode = t;
  83                         }
  84                     }
  85                     if (bParent)
  86                     {
  87                         TreeNode n = bottomnode;
  88                         while (n != uppernode.Parent)
  89                         {
  90                             if (!m_coll.Contains(n)) // new node ?
  91                                 myQueue.Enqueue(n);
  92
  93                             n = n.Parent;
  94                         }
  95                     }
  96                     // case 2 : nor the begin nor the
  97                     // end node are descendant one another
  98                     else
  99                     {
 100                         // are they siblings ?
 101
 102                         if ((uppernode.Parent == null && bottomnode.Parent == null)
 103                               || (uppernode.Parent != null &&
 104                               uppernode.Parent.Nodes.Contains(bottomnode)))
 105                         {
 106                             int nIndexUpper = uppernode.Index;
 107                             int nIndexBottom = bottomnode.Index;
 108                             if (nIndexBottom < nIndexUpper) // reversed?
 109                             {
 110                                 TreeNode t = uppernode;
 111                                 uppernode = bottomnode;
 112                                 bottomnode = t;
 113                                 nIndexUpper = uppernode.Index;
 114                                 nIndexBottom = bottomnode.Index;
 115                             }
 116
 117                             TreeNode n = uppernode;
 118                             while (nIndexUpper <= nIndexBottom)
 119                             {
 120                                 if (!m_coll.Contains(n)) // new node ?
 121                                     myQueue.Enqueue(n);
 122
 123                                 n = n.NextNode;
 124
 125                                 nIndexUpper++;
 126                             } // end while
 127
 128                         }
 129                         else
 130                         {
 131                             if (!m_coll.Contains(uppernode))
 132                                 myQueue.Enqueue(uppernode);
 133                             if (!m_coll.Contains(bottomnode))
 134                                 myQueue.Enqueue(bottomnode);
 135                         }
 136
 137                     }
 138
 139                     m_coll.AddRange(myQueue);
 140
 141                     paintSelectedNodes();
 142                     // let us chain several SHIFTs if we like it
 143                     m_firstNode = e.Node;
 144
 145                 } // end if m_bShift
 146                 else */
 147                 {
 148                     // in the case of a simple click, just add this item
 149                     if (m_coll != null && m_coll.Count > 0)
 150                     {
 151                         m_coll.Clear();
 152                     }
 153                     m_coll.Add(e.Node);
 154                 }
 155             }
 156             removePaintFromNodes();
 157         }
 158
 159         protected bool isParent(TreeNode parentNode, TreeNode childNode)
 160         {
 161             if (parentNode == childNode)
 162                 return true;
 163
 164             TreeNode n = childNode;
 165             bool bFound = false;
 166             while (!bFound && n != null)
 167             {
 168                 n = n.Parent;
 169                 bFound = (n == parentNode);
 170             }
 171             return bFound;
 172         }
 173
 174
 175         protected void paintSelectedNodes()
 176         {
 177             foreach (TreeNode n in m_coll)
 178             {
 179                 n.BackColor = SystemColors.Highlight;
 180                 n.ForeColor = SystemColors.HighlightText;
 181             }
 182         }
 183
 184         protected void removePaintFromNodes()
 185         {
 186             if (m_coll.Count == 0) return;
 187
 188             TreeNode n0 = (TreeNode)m_coll[0];
 189             Color back = n0.TreeView.BackColor;
 190             Color fore = n0.TreeView.ForeColor;
 191
 192             foreach (TreeNode n in m_coll)
 193             {
 194                 n.BackColor = back;
 195                 n.ForeColor = fore;
 196             }
 197         }
 198     }
 199 }