Code/Tools/Statoscope/Statoscope/CheckboxTreeView.cs

   1 // Copyright 2001-2019 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 using System;
   4 using System.Collections;
   5 using System.Collections.Generic;
   6 using System.Windows.Forms;
   7
   8 namespace Statoscope
   9 {
  10         public class CheckboxTreeView : TreeView
  11         {
  12                 Stack<Dictionary<TreeNode, CNodeCheckHistoryState>> m_nodeCheckStateUndoStack = new Stack<Dictionary<TreeNode, CNodeCheckHistoryState>>();
  13                 Stack<Dictionary<TreeNode, CNodeCheckHistoryState>> m_nodeCheckStateRedoStack = new Stack<Dictionary<TreeNode, CNodeCheckHistoryState>>();
  14
  15                 protected ToolTip m_toolTip;
  16                 protected bool m_refreshOnTreeNodeChecked = true;
  17                 bool m_doingUndoNodeCheckReplay = false;
  18                 bool m_addToCurrentNodeCheckUndoStates = false;
  19
  20                 public HierarchyTreeNodeCollection TreeNodeHierarchy;
  21
  22     public EventHandler HistoryStateListener;
  23
  24                 public CheckboxTreeView()
  25                 {
  26                         CheckBoxes = true;
  27                         PathSeparator = "/";
  28                         Dock = DockStyle.Fill;
  29
  30                         TreeNodeHierarchy = new HierarchyTreeNodeCollection(Nodes);
  31                         m_toolTip = new ToolTip();
  32                         m_toolTip.InitialDelay = 2000;
  33                         m_toolTip.ShowAlways = true;
  34                         m_toolTip.SetToolTip(this,
  35                                 "Right-click: toggle subtree" + Environment.NewLine +
  36                                 "Ctrl-left-click: isolate subtree");
  37                 }
  38
  39                 private const int WM_LBUTTONDBLCLK = 0x0203;
  40
  41                 // a hack to get round a bug in the TreeView implementation
  42                 protected override void WndProc(ref Message m)
  43                 {
  44                         if (m.Msg == WM_LBUTTONDBLCLK)
  45                         {
  46                                 TreeViewHitTestInfo tvhti = HitTest(new System.Drawing.Point((int)m.LParam));
  47                                 if (tvhti != null && tvhti.Location == TreeViewHitTestLocations.StateImage)
  48                                 {
  49                                         m.Result = IntPtr.Zero;
  50                                         return;
  51                                 }
  52                         }
  53                         base.WndProc(ref m);
  54                 }
  55
  56                 class CNodeCheckHistoryState
  57                 {
  58                         public bool m_beforeChecked;
  59                         public bool m_afterChecked;
  60
  61                         public CNodeCheckHistoryState(bool beforeChecked)
  62                         {
  63                                 m_beforeChecked = beforeChecked;
  64                         }
  65                 }
  66
  67                 void StartCheckStateBlock()
  68                 {
  69                         m_nodeCheckStateUndoStack.Push(new Dictionary<TreeNode, CNodeCheckHistoryState>());
  70                         m_addToCurrentNodeCheckUndoStates = true;
  71                         m_refreshOnTreeNodeChecked = false;
  72                         UpdateHistoryStateListeners();
  73                 }
  74
  75                 void EndCheckStateBlock()
  76                 {
  77                         m_refreshOnTreeNodeChecked = true;
  78                         m_addToCurrentNodeCheckUndoStates = false;
  79                 }
  80
  81                 public class CheckStateScope : IDisposable
  82                 {
  83                         private readonly CheckboxTreeView CTV;
  84
  85                         public CheckStateScope(CheckboxTreeView ctv)
  86                         {
  87                                 CTV = ctv;
  88                                 CTV.StartCheckStateBlock();
  89                         }
  90
  91                         public void Dispose()
  92                         {
  93                                 CTV.EndCheckStateBlock();
  94                         }
  95                 }
  96
  97                 public CheckStateScope CheckStateBlock()
  98                 {
  99                         return new CheckStateScope(this);
 100                 }
 101
 102                 void SetUndoNodeBeforeCheckState(TreeNode node, bool beforeCheckedState)
 103                 {
 104                         if (!m_doingUndoNodeCheckReplay)
 105                         {
 106                                 m_nodeCheckStateRedoStack.Clear();
 107
 108                                 Dictionary<TreeNode, CNodeCheckHistoryState> currentUndoNodeCheckStates;
 109
 110                                 if (m_addToCurrentNodeCheckUndoStates)
 111                                 {
 112                                         currentUndoNodeCheckStates = m_nodeCheckStateUndoStack.Peek();
 113                                 }
 114                                 else
 115                                 {
 116                                         currentUndoNodeCheckStates = new Dictionary<TreeNode, CNodeCheckHistoryState>();
 117                                         m_nodeCheckStateUndoStack.Push(currentUndoNodeCheckStates);
 118                                 }
 119
 120                                 if (!currentUndoNodeCheckStates.ContainsKey(node))
 121                                 {
 122                                         currentUndoNodeCheckStates.Add(node, new CNodeCheckHistoryState(beforeCheckedState));
 123                                 }
 124
 125                                 UpdateHistoryStateListeners();
 126                         }
 127                 }
 128
 129                 void SetUndoNodeAfterCheckState(TreeNode node, bool afterCheckedState)
 130                 {
 131                         if (!m_doingUndoNodeCheckReplay)
 132                         {
 133                                 Dictionary<TreeNode, CNodeCheckHistoryState> currentUndoNodeCheckStates = m_nodeCheckStateUndoStack.Peek();
 134                                 currentUndoNodeCheckStates[node].m_afterChecked = afterCheckedState;
 135                                 UpdateHistoryStateListeners();
 136                         }
 137                 }
 138
 139                 void UpdateHistoryStateListeners()
 140                 {
 141                         if (HistoryStateListener != null)
 142                                 HistoryStateListener(this, EventArgs.Empty);
 143                 }
 144
 145                 public virtual void Undo()
 146                 {
 147                         m_doingUndoNodeCheckReplay = true;
 148                         m_refreshOnTreeNodeChecked = false;
 149
 150                         if (m_nodeCheckStateUndoStack.Count > 0)
 151                         {
 152                                 Dictionary<TreeNode, CNodeCheckHistoryState> topUndoNodeCheckStates = m_nodeCheckStateUndoStack.Pop();
 153
 154                                 foreach (KeyValuePair<TreeNode, CNodeCheckHistoryState> undoNodeCheckStatePair in topUndoNodeCheckStates)
 155                                 {
 156                                         TreeNode node = undoNodeCheckStatePair.Key;
 157                                         node.Checked = undoNodeCheckStatePair.Value.m_beforeChecked;
 158                                 }
 159
 160                                 m_nodeCheckStateRedoStack.Push(topUndoNodeCheckStates);
 161                                 UpdateHistoryStateListeners();
 162                         }
 163
 164                         m_refreshOnTreeNodeChecked = true;
 165                         m_doingUndoNodeCheckReplay = false;
 166                 }
 167
 168                 public virtual void Redo()
 169                 {
 170                         m_doingUndoNodeCheckReplay = true;
 171                         m_refreshOnTreeNodeChecked = false;
 172
 173                         if (m_nodeCheckStateRedoStack.Count > 0)
 174                         {
 175                                 Dictionary<TreeNode, CNodeCheckHistoryState> topRedoNodeCheckStates = m_nodeCheckStateRedoStack.Pop();
 176
 177                                 foreach (KeyValuePair<TreeNode, CNodeCheckHistoryState> redoNodeCheckStatePair in topRedoNodeCheckStates)
 178                                 {
 179           TreeNode node = redoNodeCheckStatePair.Key;
 180                                         node.Checked = redoNodeCheckStatePair.Value.m_afterChecked;
 181                                 }
 182
 183                                 m_nodeCheckStateUndoStack.Push(topRedoNodeCheckStates);
 184                                 UpdateHistoryStateListeners();
 185                         }
 186
 187                         m_refreshOnTreeNodeChecked = true;
 188                         m_doingUndoNodeCheckReplay = false;
 189                 }
 190
 191                 public virtual void FilterTextChanged(string filterText)
 192                 {
 193                         m_refreshOnTreeNodeChecked = false;
 194
 195                         using (CheckStateBlock())
 196                         {
 197                                 if (filterText == "")
 198                                 {
 199                                         // check everything
 200                                         foreach (TreeNode node in GetTreeNodeEnumerator(Nodes))
 201                                         {
 202                                                 node.Checked = true;
 203                                         }
 204                                 }
 205                                 else
 206                                 {
 207                                         foreach (TreeNode node in GetTreeNodeEnumerator(Nodes))
 208                                         {
 209                                                 if (node.Text.ToUpper().Contains(filterText))
 210                                                 {
 211                                                         node.Checked = true;
 212
 213                                                         // check all parent nodes
 214                                                         for (TreeNode tn = node; tn != null; tn = tn.Parent)
 215                                                         {
 216                                                                 tn.Checked = true;
 217                                                         }
 218                                                 }
 219                                                 else
 220                                                 {
 221                                                         node.Checked = false;
 222                                                 }
 223                                         }
 224                                 }
 225                         }
 226
 227                         m_refreshOnTreeNodeChecked = true;
 228                 }
 229
 230                 public int NumUndoStates
 231                 {
 232                         get { return m_nodeCheckStateUndoStack.Count; }
 233                 }
 234
 235                 public int NumRedoStates
 236                 {
 237                         get { return m_nodeCheckStateRedoStack.Count; }
 238                 }
 239
 240                 // select treeNode in treeView, toggle its check state and set the entire subtree's check state to the new state
 241                 public void ToggleSubTree(TreeNode treeNode)
 242                 {
 243                         using (CheckStateBlock())
 244                         {
 245                                 SelectedNode = treeNode;
 246
 247                                 foreach (TreeNode node in GetTreeNodeEnumerator(treeNode.Nodes))
 248                                         node.Checked = !treeNode.Checked;
 249
 250                                 treeNode.Checked = !treeNode.Checked;
 251                         }
 252                 }
 253
 254                 public void IsolateSubTree(TreeNode treeNode)
 255                 {
 256                         using (CheckStateBlock())
 257                         {
 258                                 // uncheck everything
 259                                 foreach (TreeNode subNode in GetTreeNodeEnumerator(Nodes))
 260                                         subNode.Checked = false;
 261
 262                                 // check all sub nodes
 263                                 foreach (TreeNode subNode in GetTreeNodeEnumerator(treeNode.Nodes))
 264                                         subNode.Checked = true;
 265
 266                                 // check all parent nodes
 267                                 for (TreeNode tn = treeNode; tn != null; tn = tn.Parent)
 268                                         tn.Checked = true;
 269                         }
 270                 }
 271
 272                 static IEnumerable<TreeNode> GetTreeNodeEnumerator(TreeNodeCollection nodes)
 273                 {
 274                         foreach (TreeNode node in nodes)
 275                         {
 276                                 yield return node;
 277
 278                                 foreach (TreeNode subNode in GetTreeNodeEnumerator(node.Nodes))
 279                                 {
 280                                         yield return subNode;
 281                                 }
 282                         }
 283                 }
 284
 285                 protected void SelectNode(string[] pathLocations)
 286                 {
 287                         SelectedNode = TreeNodeHierarchy[pathLocations];
 288                         Focus();
 289                         this.PaintNow();
 290                 }
 291
 292                 protected void SelectNextClosestNode()
 293                 {
 294                         if (SelectedNode.NextNode != null)
 295                                 SelectedNode = SelectedNode.NextNode;
 296                         else if (SelectedNode.PrevNode != null)
 297                                 SelectedNode = SelectedNode.PrevNode;
 298                         else if (SelectedNode.Parent != null)
 299                                 SelectedNode = SelectedNode.Parent;
 300                 }
 301
 302                 protected override void OnBeforeCheck(TreeViewCancelEventArgs e)
 303                 {
 304                         base.OnBeforeCheck(e);
 305                         SetUndoNodeBeforeCheckState(e.Node, e.Node.Checked);
 306                 }
 307
 308                 protected override void OnAfterCheck(TreeViewEventArgs e)
 309                 {
 310                         base.OnAfterCheck(e);
 311                         SetUndoNodeAfterCheckState(e.Node, e.Node.Checked);
 312                 }
 313
 314                 protected override void OnNodeMouseClick(TreeNodeMouseClickEventArgs e)
 315                 {
 316                         base.OnNodeMouseClick(e);
 317
 318                         if (e.Button == MouseButtons.Left)
 319                         {
 320                                 if (StatoscopeForm.m_ctrlIsBeingPressed)
 321                                 {
 322                                         IsolateSubTree(e.Node);
 323                                 }
 324                         }
 325                         else if (e.Button == MouseButtons.Right)
 326                         {
 327                                 ToggleSubTree(e.Node);
 328                         }
 329                 }
 330
 331                 protected override void OnItemDrag(ItemDragEventArgs e)
 332                 {
 333                         base.OnItemDrag(e);
 334
 335                         TreeNode treeNode = (TreeNode)e.Item;
 336                         DoDragDrop("/" + treeNode.FullPath, DragDropEffects.Copy);
 337                 }
 338
 339                 // a convenience for accessing all TreeNodeHierarchy in a hierarchy - a TreeNodeCollection is just the current level
 340                 public class HierarchyTreeNodeCollection : IEnumerable
 341                 {
 342                         TreeNodeCollection Nodes;
 343
 344                         public HierarchyTreeNodeCollection(TreeNodeCollection nodes)
 345                         {
 346                                 Nodes = nodes;
 347                         }
 348
 349                         public TreeNode this[string path]
 350                         {
 351                                 get
 352                                 {
 353                                         return this[path.PathLocations()];
 354                                 }
 355                         }
 356
 357                         public TreeNode this[IEnumerable<string> pathLocations]
 358                         {
 359                                 get
 360                                 {
 361                                         TreeNode node = null;
 362                                         TreeNodeCollection nodes = Nodes;
 363
 364                                         foreach (string location in pathLocations)
 365                                         {
 366                                                 if (!nodes.ContainsKey(location))
 367                                                 {
 368                                                         return null;
 369                                                 }
 370
 371                                                 node = nodes[location];
 372                                                 nodes = node.Nodes;
 373                                         }
 374
 375                                         return node;
 376                                 }
 377                         }
 378
 379                         public bool IsChecked(string path)
 380                         {
 381                                 TreeNodeCollection nodes = Nodes;
 382
 383                                 foreach (string location in path.PathLocations())
 384                                 {
 385                                         TreeNode node = nodes[location];
 386                                         if (node == null || !node.Checked)
 387                                                 return false;
 388                                         nodes = node.Nodes;
 389                                 }
 390
 391                                 return true;
 392                         }
 393
 394                         public IEnumerator GetEnumerator()
 395                         {
 396                                 foreach (TreeNode node in Nodes)
 397                                 {
 398                                         yield return node;
 399
 400                                         foreach (TreeNode subNode in GetTreeNodeEnumerator(node.Nodes))
 401                                         {
 402                                                 yield return subNode;
 403                                         }
 404                                 }
 405                         }
 406                 }
 407         }
 408 }