mcs/class/Managed.Windows.Forms/System.Windows.Forms/TreeView.cs

   1 // Permission is hereby granted, free of charge, to any person obtaining
   2 // a copy of this software and associated documentation files (the
   3 // "Software"), to deal in the Software without restriction, including
   4 // without limitation the rights to use, copy, modify, merge, publish,
   5 // distribute, sublicense, and/or sell copies of the Software, and to
   6 // permit persons to whom the Software is furnished to do so, subject to
   7 // the following conditions:
   8 //
   9 // The above copyright notice and this permission notice shall be
  10 // included in all copies or substantial portions of the Software.
  11 //
  12 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  13 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  14 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  15 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  16 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  17 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  18 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  19 //
  20 // Copyright (c) 2004-2005 Novell, Inc.
  21 //
  22 // Authors:
  23 //      Jackson Harper (jackson@ximian.com)
  24 //      Kazuki Oikawa (kazuki@panicode.com)
  25
  26 using System;
  27 using System.Collections;
  28 using System.ComponentModel;
  29 using System.ComponentModel.Design;
  30 using System.Drawing;
  31 using System.Drawing.Drawing2D;
  32 using System.Runtime.InteropServices;
  33
  34 namespace System.Windows.Forms {
  35         [DefaultProperty("Nodes")]
  36         [DefaultEvent("AfterSelect")]
  37         [Designer("System.Windows.Forms.Design.TreeViewDesigner, " + Consts.AssemblySystem_Design, "System.ComponentModel.Design.IDesigner")]
  38         public class TreeView : Control {
  39                 #region Fields
  40                 private string path_separator = "\\";
  41                 private int item_height = -1;
  42                 private bool sorted;
  43                 internal TreeNode top_node;
  44                 internal TreeNode root_node;
  45                 internal bool nodes_added;
  46                 private TreeNodeCollection nodes;
  47
  48                 private TreeViewAction selection_action = TreeViewAction.Unknown;
  49                 internal TreeNode selected_node = null;
  50                 private TreeNode focused_node = null;
  51                 private TreeNode highlighted_node;
  52                 private Rectangle mouse_rect = Rectangle.Empty;
  53                 private bool select_mmove = false;
  54
  55                 private ImageList image_list;
  56                 private int image_index = -1;
  57                 private int selected_image_index = -1;
  58
  59                 private bool full_row_select;
  60                 private bool hot_tracking;
  61                 private int indent = 19;
  62
  63                 private NodeLabelEditEventArgs edit_args;
  64                 private LabelEditTextBox edit_text_box;
  65                 internal TreeNode edit_node;
  66
  67                 private bool checkboxes;
  68                 private bool label_edit;
  69                 private bool scrollable = true;
  70                 private bool show_lines = true;
  71                 private bool show_root_lines = true;
  72                 private bool show_plus_minus = true;
  73                 private bool hide_selection = true;
  74
  75                 private int max_visible_order = -1;
  76                 private VScrollBar vbar;
  77                 private HScrollBar hbar;
  78                 private bool vbar_bounds_set;
  79                 private bool hbar_bounds_set;
  80                 internal int skipped_nodes;
  81                 internal int hbar_offset;
  82
  83                 private int update_stack;
  84                 private bool update_needed;
  85
  86                 private Pen dash;
  87                 private StringFormat string_format;
  88
  89                 private int drag_begin_x = 0;
  90                 private int drag_begin_y = 0;
  91                 private long handle_count = 1;
  92
  93                 #endregion      // Fields
  94
  95                 #region Public Constructors
  96                 public TreeView ()
  97                 {
  98                         border_style = BorderStyle.Fixed3D;
  99                         base.background_color = ThemeEngine.Current.ColorWindow;
 100                         base.foreground_color = ThemeEngine.Current.ColorWindowText;
 101
 102                         root_node = new TreeNode (this);
 103                         root_node.Text = "ROOT NODE";
 104                         nodes = new TreeNodeCollection (root_node);
 105                         root_node.SetNodes (nodes);
 106
 107                         MouseDown += new MouseEventHandler (MouseDownHandler);
 108                         MouseUp += new MouseEventHandler(MouseUpHandler);
 109                         MouseMove += new MouseEventHandler(MouseMoveHandler);
 110                         SizeChanged += new EventHandler (SizeChangedHandler);
 111                         FontChanged += new EventHandler (FontChangedHandler);
 112                         LostFocus += new EventHandler (LostFocusHandler);
 113                         GotFocus += new EventHandler (GotFocusHandler);
 114                         MouseWheel += new MouseEventHandler(MouseWheelHandler);
 115
 116                         SetStyle (ControlStyles.UserPaint | ControlStyles.StandardClick
 117 #if NET_2_0
 118                                 | ControlStyles.UseTextForAccessibility
 119 #endif
 120                                 , false);
 121
 122                         string_format = new StringFormat ();
 123                         string_format.LineAlignment = StringAlignment.Center;
 124                         string_format.Alignment = StringAlignment.Center;
 125
 126                         vbar = new ImplicitVScrollBar ();
 127                         hbar = new ImplicitHScrollBar ();
 128
 129                         vbar.Visible = false;
 130                         hbar.Visible = false;
 131                         vbar.ValueChanged += new EventHandler (VScrollBarValueChanged);
 132                         hbar.ValueChanged += new EventHandler (HScrollBarValueChanged);
 133
 134                         SuspendLayout ();
 135                         Controls.AddImplicit (vbar);
 136                         Controls.AddImplicit (hbar);
 137                         ResumeLayout ();
 138                 }
 139
 140                 #endregion      // Public Constructors
 141
 142                 #region Public Instance Properties
 143                 public override Color BackColor {
 144                         get { return base.BackColor;}
 145                         set { base.BackColor = value; }
 146                 }
 147
 148
 149                 [Browsable(false)]
 150                 [EditorBrowsable(EditorBrowsableState.Never)]
 151                 public override Image BackgroundImage {
 152                         get { return base.BackgroundImage; }
 153                         set { base.BackgroundImage = value; }
 154                 }
 155
 156                 [DefaultValue(BorderStyle.Fixed3D)]
 157                 [DispId(-504)]
 158                 public BorderStyle BorderStyle {
 159                         get { return InternalBorderStyle; }
 160                         set { InternalBorderStyle  = value; }
 161                 }
 162
 163                 [DefaultValue(false)]
 164                 public bool CheckBoxes {
 165                         get { return checkboxes; }
 166                         set {
 167                                 if (value == checkboxes)
 168                                         return;
 169                                 checkboxes = value;
 170
 171                                 // Match a "bug" in the MS implementation where disabling checkboxes
 172                                 // collapses the entire tree, but enabling them does not affect the
 173                                 // state of the tree.
 174                                 if (!checkboxes)
 175                                         root_node.CollapseAllUncheck ();
 176
 177                                 Invalidate ();
 178                         }
 179                 }
 180
 181                 public override Color ForeColor {
 182                         get { return base.ForeColor; }
 183                         set { base.ForeColor = value; }
 184                 }
 185                 [DefaultValue(false)]
 186                 public bool FullRowSelect {
 187                         get { return full_row_select; }
 188                         set {
 189                                 if (value == full_row_select)
 190                                         return;
 191                                 full_row_select = value;
 192                                 Invalidate ();
 193                         }
 194                 }
 195                 [DefaultValue(true)]
 196                 public bool HideSelection {
 197                         get { return hide_selection; }
 198                         set {
 199                                 if (hide_selection == value)
 200                                         return;
 201                                 hide_selection = value;
 202                                 Invalidate ();
 203                         }
 204                 }
 205
 206                 [DefaultValue(false)]
 207                 public bool HotTracking {
 208                         get { return hot_tracking; }
 209                         set { hot_tracking = value; }
 210                 }
 211
 212                 [DefaultValue(0)]
 213                 [Editor("System.Windows.Forms.Design.ImageIndexEditor, " + Consts.AssemblySystem_Design, typeof(System.Drawing.Design.UITypeEditor))]
 214                 [Localizable(true)]
 215                 [TypeConverter(typeof(TreeViewImageIndexConverter))]
 216                 public int ImageIndex {
 217                         get { return image_index; }
 218                         set {
 219                                 if (value < -1) {
 220                                         throw new ArgumentException ("'" + value + "' is not a valid value for 'value'. " +
 221                                                 "'value' must be greater than or equal to 0.");
 222                                 }
 223                                 if (image_index == value)
 224                                         return;
 225                                 image_index = value;
 226                                 Invalidate ();
 227                         }
 228                 }
 229
 230                 [DefaultValue(null)]
 231                 public ImageList ImageList {
 232                         get { return image_list; }
 233                         set {
 234                                 image_list = value;
 235                                 Invalidate ();
 236                         }
 237                 }
 238
 239                 [Localizable(true)]
 240                 public int Indent {
 241                         get { return indent; }
 242                         set {
 243                                 if (indent == value)
 244                                         return;
 245                                 if (value > 32000) {
 246                                         throw new ArgumentException ("'" + value + "' is not a valid value for 'Indent'. " +
 247                                                 "'Indent' must be less than or equal to 32000");
 248                                 }
 249                                 if (value < 0) {
 250                                         throw new ArgumentException ("'" + value + "' is not a valid value for 'Indent'. " +
 251                                                 "'Indent' must be greater than or equal to 0.");
 252                                 }
 253                                 indent = value;
 254                                 Invalidate ();
 255                         }
 256                 }
 257
 258                 [Localizable(true)]
 259                 public int ItemHeight {
 260                         get {
 261                                 if (item_height == -1)
 262                                         return FontHeight + 3;
 263                                 return item_height;
 264                         }
 265                         set {
 266                                 if (value == item_height)
 267                                         return;
 268                                 item_height = value;
 269                                 Invalidate ();
 270                         }
 271                 }
 272
 273                 internal int ActualItemHeight {
 274                         get {
 275                                 int res = ItemHeight;
 276                                 if (ImageList != null && ImageList.ImageSize.Height > res)
 277                                         res = ImageList.ImageSize.Height;
 278                                 return res;
 279                         }
 280                 }
 281
 282                 [DefaultValue(false)]
 283                 public bool LabelEdit {
 284                         get { return label_edit; }
 285                         set { label_edit = value; }
 286                 }
 287
 288                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
 289                 [MergableProperty(false)]
 290                 [Localizable(true)]
 291                 public TreeNodeCollection Nodes {
 292                         get { return nodes; }
 293                 }
 294
 295                 [DefaultValue("\\")]
 296                 public string PathSeparator {
 297                         get { return path_separator; }
 298                         set { path_separator = value; }
 299                 }
 300
 301                 [DefaultValue(true)]
 302                 public bool Scrollable {
 303                         get { return scrollable; }
 304                         set {
 305                                 if (scrollable == value)
 306                                         return;
 307                                 scrollable = value;
 308                                 UpdateScrollBars ();
 309                         }
 310                 }
 311
 312                 [Editor("System.Windows.Forms.Design.ImageIndexEditor, " + Consts.AssemblySystem_Design, typeof(System.Drawing.Design.UITypeEditor))]
 313                 [TypeConverter(typeof(TreeViewImageIndexConverter))]
 314                 [Localizable(true)]
 315                 [DefaultValue(0)]
 316                 public int SelectedImageIndex {
 317                         get { return selected_image_index; }
 318                         set {
 319                                 if (value < -1) {
 320                                         throw new ArgumentException ("'" + value + "' is not a valid value for 'value'. " +
 321                                                 "'value' must be greater than or equal to 0.");
 322                                 }
 323                                 UpdateNode (SelectedNode);
 324                         }
 325                 }
 326
 327                 [Browsable(false)]
 328                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 329                 public TreeNode SelectedNode {
 330                         get { return selected_node; }
 331                         set {
 332                                 if (selected_node == value) {
 333                                         selection_action = TreeViewAction.Unknown;
 334                                         return;
 335                                 }
 336
 337                                 TreeViewCancelEventArgs e = new TreeViewCancelEventArgs (value, false, selection_action);
 338                                 OnBeforeSelect (e);
 339
 340                                 if (e.Cancel)
 341                                         return;
 342
 343                                 Rectangle invalid = Rectangle.Empty;
 344
 345                                 if (selected_node != null) {
 346                                         invalid = Bloat (selected_node.Bounds);
 347                                 }
 348                                 if (focused_node != null) {
 349                                         invalid = Rectangle.Union (invalid,
 350                                                         Bloat (focused_node.Bounds));
 351                                 }
 352
 353                                 if (value != null)
 354                                         invalid = Rectangle.Union (invalid, Bloat (value.Bounds));
 355
 356                                 highlighted_node = value;
 357                                 selected_node = value;
 358                                 focused_node = value;
 359
 360                                 if (full_row_select) {
 361                                         invalid.X = 0;
 362                                         invalid.Width = ViewportRectangle.Width;
 363                                 }
 364
 365                                 if (invalid != Rectangle.Empty)
 366                                         Invalidate (invalid);
 367
 368                                 // We ensure its visible after we update because
 369                                 // scrolling is used for insure visible
 370                                 if (selected_node != null)
 371                                         selected_node.EnsureVisible ();
 372
 373                                 OnAfterSelect (new TreeViewEventArgs (value, TreeViewAction.Unknown));
 374                                 selection_action = TreeViewAction.Unknown;
 375                         }
 376                 }
 377
 378                 private Rectangle Bloat (Rectangle rect)
 379                 {
 380                         rect.Y--;
 381                         rect.X--;
 382                         rect.Height += 2;
 383                         rect.Width += 2;
 384                         return rect;
 385                 }
 386
 387                 [DefaultValue(true)]
 388                 public bool ShowLines {
 389                         get { return show_lines; }
 390                         set {
 391                                 if (show_lines == value)
 392                                         return;
 393                                 show_lines = value;
 394                                 Invalidate ();
 395                         }
 396                 }
 397
 398                 [DefaultValue(true)]
 399                 public bool ShowPlusMinus {
 400                         get { return show_plus_minus; }
 401                         set {
 402                                 if (show_plus_minus == value)
 403                                         return;
 404                                 show_plus_minus = value;
 405                                 Invalidate ();
 406                         }
 407                 }
 408
 409                 [DefaultValue(true)]
 410                 public bool ShowRootLines {
 411                         get { return show_root_lines; }
 412                         set {
 413                                 if (show_root_lines == value)
 414                                         return;
 415                                 show_root_lines = value;
 416                                 Invalidate ();
 417                         }
 418                 }
 419
 420                 [DefaultValue(false)]
 421                 public bool Sorted {
 422                         get { return sorted; }
 423                         set {
 424                                 if (sorted != value)
 425                                         sorted = value;
 426                                 if (sorted) {
 427                                         Nodes.Sort ();
 428                                         top_node = root_node;
 429                                         RecalculateVisibleOrder (root_node);
 430                                         UpdateScrollBars ();
 431                                         Invalidate ();
 432                                 }
 433                         }
 434                 }
 435
 436                 [Browsable(false)]
 437                 [EditorBrowsable(EditorBrowsableState.Never)]
 438                 [Bindable(false)]
 439                 public override string Text {
 440                         get { return base.Text; }
 441                         set { base.Text = value; }
 442                 }
 443
 444                 [Browsable(false)]
 445                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 446                 public TreeNode TopNode {
 447                         get { return top_node; }
 448                 }
 449
 450                 [Browsable(false)]
 451                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 452                 public int VisibleCount {
 453                         get {
 454                                 return ViewportRectangle.Height / ActualItemHeight;
 455                         }
 456                 }
 457
 458                 #endregion      // Public Instance Properties
 459
 460                 #region Protected Instance Properties
 461                 protected override CreateParams CreateParams {
 462                         get {
 463                                 CreateParams cp = base.CreateParams;
 464                                 return cp;
 465                         }
 466                 }
 467
 468                 protected override Size DefaultSize {
 469                         get { return new Size (121, 97); }
 470                 }
 471
 472                 #endregion      // Protected Instance Properties
 473
 474                 #region Public Instance Methods
 475                 public void BeginUpdate ()
 476                 {
 477                         update_stack++;
 478                 }
 479
 480                 public void EndUpdate ()
 481                 {
 482                         if (update_stack > 1) {
 483                                 update_stack--;
 484                         } else {
 485                                 update_stack = 0;
 486                                 if (update_needed) {
 487                                         RecalculateVisibleOrder (root_node);
 488                                         UpdateScrollBars ();
 489                                         if (SelectedNode != null)
 490                                                 SelectedNode.EnsureVisible ();
 491                                         Invalidate (ViewportRectangle);
 492                                         update_needed = false;
 493                                 }
 494                         }
 495                 }
 496
 497                 public void ExpandAll ()
 498                 {
 499                         BeginUpdate ();
 500                         root_node.ExpandAll ();
 501
 502                         EndUpdate ();
 503
 504                         // Walk all the way to the end, then walk back visible count
 505                         //to find the new top node
 506                         OpenTreeNodeEnumerator walk = new OpenTreeNodeEnumerator (root_node);
 507                         while (walk.MoveNext ())
 508                         { }
 509
 510                         for (int i = 0; i < VisibleCount - 1; i++)
 511                                 walk.MovePrevious ();
 512
 513                         SetTop (walk.CurrentNode);
 514                 }
 515
 516
 517                 public void CollapseAll ()
 518                 {
 519                         TreeNode walk = top_node;
 520
 521                         while (walk.parent != root_node)
 522                                 walk = walk.parent;
 523
 524                         BeginUpdate ();
 525                         root_node.CollapseAll ();
 526                         EndUpdate ();
 527
 528                         SetTop (walk);
 529                 }
 530
 531                 public TreeNode GetNodeAt (Point pt) {
 532                         return GetNodeAt (pt.Y);
 533                 }
 534
 535                 public TreeNode GetNodeAt (int x, int y)
 536                 {
 537                         return GetNodeAt (y);
 538                 }
 539
 540                 private TreeNode GetNodeAtUseX (int x, int y) {
 541                         TreeNode node = GetNodeAt (y);
 542                         if (node == null || !(IsTextArea (node, x) || full_row_select))
 543                                 return null;
 544                         return node;
 545
 546                 }
 547
 548                 public int GetNodeCount (bool include_subtrees) {
 549                         return root_node.GetNodeCount (include_subtrees);
 550                 }
 551
 552                 public override string ToString () {
 553                         int count = Nodes.Count;
 554                         if (count <= 0)
 555                                 return String.Concat (base.ToString (), "Node Count: 0");
 556                         return String.Concat (base.ToString (), "Node Count: ", count, " Nodes[0]: ", Nodes [0]);
 557
 558                 }
 559
 560                 #endregion      // Public Instance Methods
 561
 562                 #region Protected Instance Methods
 563                 protected override void CreateHandle () {
 564                         base.CreateHandle ();
 565
 566                         UpdateScrollBars ();
 567                 }
 568
 569                 protected override void Dispose (bool disposing) {
 570                         if (disposing)
 571                                 image_list = null;
 572
 573                         base.Dispose (disposing);
 574                 }
 575
 576                 protected OwnerDrawPropertyBag GetItemRenderStyles (TreeNode node, int state) {
 577                         return node.prop_bag;
 578                 }
 579
 580                 protected override bool IsInputKey (Keys key_data)
 581                 {
 582                         if ((key_data & Keys.Alt) == 0) {
 583                                 switch (key_data & Keys.KeyCode) {
 584                                 case Keys.Enter:
 585                                 case Keys.Escape:
 586                                 case Keys.Prior:
 587                                 case Keys.Next:
 588                                 case Keys.End:
 589                                 case Keys.Home:
 590                                 case Keys.Left:
 591                                 case Keys.Up:
 592                                 case Keys.Right:
 593                                 case Keys.Down:
 594                                         return true;
 595                                 }
 596                         }
 597                         return base.IsInputKey (key_data);
 598                 }
 599
 600                 protected override void OnKeyDown (KeyEventArgs e)
 601                 {
 602                         OpenTreeNodeEnumerator ne;
 603
 604                         switch (e.KeyData & Keys.KeyCode) {
 605                         case Keys.Add:
 606                                 if (selected_node != null && selected_node.IsExpanded)
 607                                         selected_node.Expand ();
 608                                 break;
 609                         case Keys.Subtract:
 610                                 if (selected_node != null && selected_node.IsExpanded)
 611                                         selected_node.Collapse ();
 612                                 break;
 613                         case Keys.Left:
 614                                 if (selected_node != null) {
 615                                         if (selected_node.IsExpanded)
 616                                                 selected_node.Collapse ();
 617                                         else {
 618                                                 TreeNode parent = selected_node.Parent;
 619                                                 if (parent != null) {
 620                                                         selection_action = TreeViewAction.ByKeyboard;
 621                                                         SelectedNode = parent;
 622                                                 }
 623                                         }
 624                                 }
 625                                 break;
 626                         case Keys.Right:
 627                                 if (selected_node != null) {
 628                                         if (!selected_node.IsExpanded)
 629                                                 selected_node.Expand ();
 630                                         else {
 631                                                 TreeNode child = selected_node.FirstNode;
 632                                                 if (child != null)
 633                                                         SelectedNode = child;
 634                                         }
 635                                 }
 636                                 break;
 637                         case Keys.Up:
 638                                 if (selected_node != null) {
 639                                         ne = new OpenTreeNodeEnumerator (selected_node);
 640                                         if (ne.MovePrevious () && ne.MovePrevious ()) {
 641                                                 selection_action = TreeViewAction.ByKeyboard;
 642                                                 SelectedNode = ne.CurrentNode;
 643                                         }
 644                                 }
 645                                 break;
 646                         case Keys.Down:
 647                                 if (selected_node != null) {
 648                                         ne = new OpenTreeNodeEnumerator (selected_node);
 649                                         if (ne.MoveNext () && ne.MoveNext ()) {
 650                                                 selection_action = TreeViewAction.ByKeyboard;
 651                                                 SelectedNode = ne.CurrentNode;
 652                                         }
 653                                 }
 654                                 break;
 655                         case Keys.Home:
 656                                 if (root_node.Nodes.Count > 0) {
 657                                         ne = new OpenTreeNodeEnumerator (root_node.Nodes [0]);
 658                                         if (ne.MoveNext ()) {
 659                                                 selection_action = TreeViewAction.ByKeyboard;
 660                                                 SelectedNode = ne.CurrentNode;
 661                                         }
 662                                 }
 663                                 break;
 664                         case Keys.End:
 665                                 if (root_node.Nodes.Count > 0) {
 666                                         ne = new OpenTreeNodeEnumerator (root_node.Nodes [0]);
 667                                         while (ne.MoveNext ())
 668                                         { }
 669                                         selection_action = TreeViewAction.ByKeyboard;
 670                                         SelectedNode = ne.CurrentNode;
 671                                 }
 672                                 break;
 673                         case Keys.PageDown:
 674                                 if (selected_node != null) {
 675                                         ne = new OpenTreeNodeEnumerator (selected_node);
 676                                         int move = VisibleCount;
 677                                         for (int i = 0; i < move && ne.MoveNext (); i++) {
 678
 679                                         }
 680                                         selection_action = TreeViewAction.ByKeyboard;
 681                                         SelectedNode = ne.CurrentNode;
 682                                 }
 683                                 break;
 684                         case Keys.PageUp:
 685                                 if (selected_node != null) {
 686                                         ne = new OpenTreeNodeEnumerator (selected_node);
 687                                         int move = VisibleCount;
 688                                         for (int i = 0; i < move && ne.MovePrevious (); i++)
 689                                         { }
 690                                         selection_action = TreeViewAction.ByKeyboard;
 691                                         SelectedNode = ne.CurrentNode;
 692                                 }
 693                                 break;
 694                         case Keys.Multiply:
 695                                 if (selected_node != null)
 696                                         selected_node.ExpandAll ();
 697                                 break;
 698                         }
 699                         base.OnKeyDown (e);
 700
 701                         if (!e.Handled && checkboxes &&
 702                              selected_node != null &&
 703                             (e.KeyData & Keys.KeyCode) == Keys.Space) {
 704                                 selected_node.check_reason = TreeViewAction.ByKeyboard;
 705                                 selected_node.Checked = !selected_node.Checked;
 706                                 e.Handled = true;
 707                         }
 708                 }
 709
 710                 protected override void OnKeyPress (KeyPressEventArgs e)
 711                 {
 712                         base.OnKeyPress (e);
 713                         if (e.KeyChar == ' ')
 714                                 e.Handled = true;
 715                 }
 716
 717                 protected override void OnKeyUp (KeyEventArgs e)
 718                 {
 719                         base.OnKeyUp (e);
 720                         if ((e.KeyData & Keys.KeyCode) == Keys.Space)
 721                                 e.Handled = true;
 722                 }
 723
 724                 protected virtual void OnItemDrag (ItemDragEventArgs e)
 725                 {
 726                         ItemDragEventHandler eh = (ItemDragEventHandler)(Events [ItemDragEvent]);
 727                         if (eh != null)
 728                                 eh (this, e);
 729                 }
 730
 731                 protected internal virtual void OnAfterCheck (TreeViewEventArgs e) {
 732                         TreeViewEventHandler eh = (TreeViewEventHandler)(Events [AfterCheckEvent]);
 733                         if (eh != null)
 734                                 eh (this, e);
 735                 }
 736
 737                 protected internal virtual void OnAfterCollapse (TreeViewEventArgs e) {
 738                         TreeViewEventHandler eh = (TreeViewEventHandler)(Events [AfterCollapseEvent]);
 739                         if (eh != null)
 740                                 eh (this, e);
 741                 }
 742
 743                 protected internal virtual void OnAfterExpand (TreeViewEventArgs e) {
 744                         TreeViewEventHandler eh = (TreeViewEventHandler)(Events [AfterExpandEvent]);
 745                         if (eh != null)
 746                                 eh (this, e);
 747                 }
 748
 749                 protected virtual void OnAfterLabelEdit (NodeLabelEditEventArgs e) {
 750                         NodeLabelEditEventHandler eh = (NodeLabelEditEventHandler)(Events [AfterLabelEditEvent]);
 751                         if (eh != null)
 752                                 eh (this, e);
 753                 }
 754
 755                 protected virtual void OnAfterSelect (TreeViewEventArgs e) {
 756                         TreeViewEventHandler eh = (TreeViewEventHandler)(Events [AfterSelectEvent]);
 757                         if (eh != null)
 758                                 eh (this, e);
 759                 }
 760
 761                 protected internal virtual void OnBeforeCheck (TreeViewCancelEventArgs e) {
 762                         TreeViewCancelEventHandler eh = (TreeViewCancelEventHandler)(Events [BeforeCheckEvent]);
 763                         if (eh != null)
 764                                 eh (this, e);
 765                 }
 766
 767                 protected internal virtual void OnBeforeCollapse (TreeViewCancelEventArgs e) {
 768                         TreeViewCancelEventHandler eh = (TreeViewCancelEventHandler)(Events [BeforeCollapseEvent]);
 769                         if (eh != null)
 770                                 eh (this, e);
 771                 }
 772
 773                 protected internal virtual void OnBeforeExpand (TreeViewCancelEventArgs e) {
 774                         TreeViewCancelEventHandler eh = (TreeViewCancelEventHandler)(Events [BeforeExpandEvent]);
 775                         if (eh != null)
 776                                 eh (this, e);
 777                 }
 778
 779                 protected virtual void OnBeforeLabelEdit (NodeLabelEditEventArgs e) {
 780                         NodeLabelEditEventHandler eh = (NodeLabelEditEventHandler)(Events [BeforeLabelEditEvent]);
 781                         if (eh != null)
 782                                 eh (this, e);
 783                 }
 784
 785                 protected virtual void OnBeforeSelect (TreeViewCancelEventArgs e) {
 786                         TreeViewCancelEventHandler eh = (TreeViewCancelEventHandler)(Events [BeforeSelectEvent]);
 787                         if (eh != null)
 788                                 eh (this, e);
 789                 }
 790
 791                 protected override void OnHandleCreated (EventArgs e) {
 792                         base.OnHandleCreated (e);
 793                 }
 794
 795                 protected override void OnHandleDestroyed (EventArgs e) {
 796                         base.OnHandleDestroyed (e);
 797                 }
 798
 799                 protected override void WndProc(ref Message m) {
 800                         switch ((Msg) m.Msg) {
 801
 802                         case Msg.WM_LBUTTONDBLCLK:
 803                                 int val = m.LParam.ToInt32();
 804                                 DoubleClickHandler (null, new
 805                                                 MouseEventArgs (MouseButtons.Left,
 806                                                                 2, val & 0xffff,
 807                                                                 (val>>16) & 0xffff, 0));
 808                                         break;
 809                         }
 810                         base.WndProc (ref m);
 811                 }
 812
 813                 #endregion      // Protected Instance Methods
 814
 815                 #region Internal & Private Methods and Properties
 816                 internal IntPtr CreateNodeHandle ()
 817                 {
 818                         return (IntPtr) handle_count++;
 819                 }
 820
 821                 internal TreeNode NodeFromHandle (IntPtr handle)
 822                 {
 823                         // This method is called rarely, so instead of maintaining a table
 824                         // we just walk the tree nodes to find the matching handle
 825                         return NodeFromHandleRecursive (root_node,  handle);
 826                 }
 827
 828                 private TreeNode NodeFromHandleRecursive (TreeNode node, IntPtr handle)
 829                 {
 830                         if (node.handle == handle)
 831                                 return node;
 832                         foreach (TreeNode child in node.Nodes) {
 833                                 TreeNode match = NodeFromHandleRecursive (child, handle);
 834                                 if (match != null)
 835                                         return match;
 836                         }
 837                         return null;
 838                 }
 839
 840                 internal Rectangle ViewportRectangle {
 841                         get {
 842                                 Rectangle res = ClientRectangle;
 843
 844                                 if (vbar != null && vbar.Visible)
 845                                         res.Width -= vbar.Width;
 846                                 if (hbar != null && hbar.Visible)
 847                                         res.Height -= hbar.Height;
 848                                 return res;
 849                         }
 850                 }
 851
 852                 private TreeNode GetNodeAt (int y)
 853                 {
 854                         if (nodes.Count <= 0)
 855                                 return null;
 856
 857                         if (top_node == null)
 858                                 top_node = nodes [0];
 859
 860                         OpenTreeNodeEnumerator o = new OpenTreeNodeEnumerator (TopNode);
 861                         int move = y / ActualItemHeight;
 862                         for (int i = -1; i < move; i++) {
 863                                 if (!o.MoveNext ())
 864                                         return null;
 865                         }
 866
 867                         return o.CurrentNode;
 868                 }
 869
 870                 private bool IsTextArea (TreeNode node, int x)
 871                 {
 872                         return node != null && node.Bounds.Left <= x && node.Bounds.Right >= x;
 873                 }
 874
 875                 private bool IsSelectableArea (TreeNode node, int x)
 876                 {
 877                         if (node == null)
 878                                 return false;
 879                         int l = node.Bounds.Left;
 880                         if (ImageList != null)
 881                                 l -= ImageList.ImageSize.Width;
 882                         return l <= x && node.Bounds.Right >= x;
 883
 884                 }
 885
 886                 private bool IsPlusMinusArea (TreeNode node, int x)
 887                 {
 888                         if (node.Nodes.Count == 0 || (node.parent == root_node && !show_root_lines))
 889                                 return false;
 890
 891                         int l = node.Bounds.Left + 5;
 892
 893                         if (show_root_lines || node.Parent != null)
 894                                 l -= indent;
 895                         if (ImageList != null)
 896                                 l -= ImageList.ImageSize.Width + 3;
 897                         if (checkboxes)
 898                                 l -= 19;
 899                         return (x > l && x < l + 8);
 900                 }
 901
 902                 private bool IsCheckboxArea (TreeNode node, int x)
 903                 {
 904                         int l = CheckBoxLeft (node);
 905                         return (x > l && x < l + 10);
 906                 }
 907
 908                 private int CheckBoxLeft (TreeNode node)
 909                 {
 910                         int l = node.Bounds.Left + 5;
 911
 912                         if (show_root_lines || node.Parent != null)
 913                                 l -= indent;
 914                         if (ImageList != null)
 915                                 l -= ImageList.ImageSize.Width + 3;
 916
 917                         return l;
 918                 }
 919
 920                 internal void RecalculateVisibleOrder (TreeNode start)
 921                 {
 922                         if (update_stack > 0)
 923                                 return;
 924
 925                         int order;
 926                         if (start == null) {
 927                                 start = root_node;
 928                                 order = 0;
 929                         } else
 930                                 order = start.visible_order;
 931
 932                         OpenTreeNodeEnumerator walk = new OpenTreeNodeEnumerator (start);
 933                         while (walk.MoveNext ()) {
 934                                 walk.CurrentNode.visible_order = order;
 935                                 order++;
 936                         }
 937
 938                         max_visible_order = order;
 939                 }
 940
 941                 internal void SetTop (TreeNode node)
 942                 {
 943                         if (!vbar.Visible)
 944                                 return;
 945
 946                         TreeNode first = root_node.FirstNode;
 947
 948                         if (first == null)
 949                                 return;  // I don't think its possible for this to happen
 950
 951                         OpenTreeNodeEnumerator walk = new OpenTreeNodeEnumerator (first);
 952                         int offset = -1;
 953                         int vc = VisibleCount;
 954                         while (walk.CurrentNode != node && walk.MoveNext () && offset < vbar.Maximum - vc)
 955                                 offset++;
 956
 957                         SetVScrollTop (walk.CurrentNode);
 958                 }
 959
 960                 internal void SetBottom (TreeNode node)
 961                 {
 962                         if (!vbar.Visible)
 963                                 return;
 964
 965                         OpenTreeNodeEnumerator walk = new OpenTreeNodeEnumerator (node);
 966
 967                         int bottom = ViewportRectangle.Bottom;
 968                         int offset = 0;
 969                         while (walk.MovePrevious ()) {
 970                                 if (walk.CurrentNode.Bounds.Bottom <= bottom)
 971                                         break;
 972                                 offset++;
 973                         }
 974
 975                         int nv = vbar.Value + offset;
 976                         if (vbar.Value + offset < vbar.Maximum) {
 977                                 vbar.Value = nv;
 978                         } else {
 979 #if DEBUG
 980                                 Console.Error.WriteLine ("setting bottom to value greater then maximum ({0}, {1})",
 981                                                 nv, vbar.Maximum);
 982 #endif
 983                         }
 984
 985                 }
 986
 987                 internal void UpdateBelow (TreeNode node)
 988                 {
 989                         if (update_stack > 0) {
 990                                 update_needed = true;
 991                                 return;
 992                         }
 993
 994                         if (node == root_node) {
 995                                 Invalidate (ViewportRectangle);
 996                                 return;
 997                         }
 998
 999                         // We need to update the current node so the plus/minus block gets update too
1000                         int top = Math.Max (node.Bounds.Top - 1, 0);
1001                         Rectangle invalid = new Rectangle (0, top,
1002                                         Width, Height - top);
1003                         Invalidate (invalid);
1004                 }
1005
1006                 internal void UpdateNode (TreeNode node)
1007                 {
1008                         if (node == null)
1009                                 return;
1010
1011                         if (update_stack > 0) {
1012                                 update_needed = true;
1013                                 return;
1014                         }
1015
1016                         if (node == root_node) {
1017                                 Invalidate ();
1018                                 return;
1019                         }
1020
1021                         Rectangle invalid = new Rectangle (0, node.Bounds.Top - 1, Width,
1022                                         node.Bounds.Height + 1);
1023                         Invalidate (invalid);
1024                 }
1025
1026                 internal void UpdateNodePlusMinus (TreeNode node)
1027                 {
1028                         if (update_stack > 0) {
1029                                 update_needed = true;
1030                                 return;
1031                         }
1032
1033                         int l = node.Bounds.Left + 5;
1034
1035                         if (show_root_lines || node.Parent != null)
1036                                 l -= indent;
1037                         if (ImageList != null)
1038                                 l -= ImageList.ImageSize.Width + 3;
1039                         if (checkboxes)
1040                                 l -= 19;
1041
1042                         Invalidate (new Rectangle (l, node.Bounds.Top, 8, node.Bounds.Height));
1043                 }
1044
1045                 internal override void OnPaintInternal (PaintEventArgs pe)
1046                 {
1047                         Draw (pe.ClipRectangle, pe.Graphics);
1048                 }
1049
1050                 private void Draw (Rectangle clip, Graphics dc)
1051                 {
1052                         dc.FillRectangle (ThemeEngine.Current.ResPool.GetSolidBrush (BackColor), clip);
1053
1054                         Color dash_color = ControlPaint.Dark (BackColor);
1055                         if (dash_color == BackColor)
1056                                 dash_color = ControlPaint.Light (BackColor);
1057                         dash = new Pen (dash_color, 1);
1058                         dash.DashStyle = DashStyle.Dot;
1059
1060                         Rectangle viewport = ViewportRectangle;
1061                         Rectangle original_clip = clip;
1062                         if (clip.Bottom > viewport.Bottom)
1063                                 clip.Height = viewport.Bottom - clip.Top;
1064
1065                         OpenTreeNodeEnumerator walk = new OpenTreeNodeEnumerator (TopNode);
1066                         while (walk.MoveNext ()) {
1067                                 TreeNode current = walk.CurrentNode;
1068
1069                                 // Haven't gotten to visible nodes yet
1070                                 if (current.GetY () + ActualItemHeight < clip.Top)
1071                                         continue;
1072
1073                                 // Past the visible nodes
1074                                 if (current.GetY () > clip.Bottom)
1075                                         break;
1076
1077                                 DrawNode (current, dc, clip);
1078                         }
1079
1080                         if (hbar.Visible && vbar.Visible) {
1081                                 Rectangle corner = new Rectangle (hbar.Right, vbar.Bottom, vbar.Width, hbar.Height);
1082                                 if (original_clip.IntersectsWith (corner))
1083                                         dc.FillRectangle (ThemeEngine.Current.ResPool.GetSolidBrush (ThemeEngine.Current.ColorControl),
1084                                                         corner);
1085                         }
1086                 }
1087
1088                 private void DrawNodePlusMinus (TreeNode node, Graphics dc, int x, int middle)
1089                 {
1090                         dc.DrawRectangle (SystemPens.ControlDark, x, middle - 4, 8, 8);
1091
1092                         if (node.IsExpanded) {
1093                                 dc.DrawLine (SystemPens.ControlDarkDark, x + 2, middle, x + 6, middle);
1094                         } else {
1095                                 dc.DrawLine (SystemPens.ControlDarkDark, x + 2, middle, x + 6, middle);
1096                                 dc.DrawLine (SystemPens.ControlDarkDark, x + 4, middle - 2, x + 4, middle + 2);
1097                         }
1098                 }
1099
1100                 private void DrawNodeCheckBox (TreeNode node, Graphics dc, int x, int middle)
1101                 {
1102                         Pen pen = ThemeEngine.Current.ResPool.GetSizedPen(Color.Black, 2);
1103                                 dc.DrawRectangle (pen, x + 3, middle - 4, 11, 11);
1104
1105                         if (node.Checked) {
1106                                 Pen check_pen = ThemeEngine.Current.ResPool.GetPen(Color.Black);
1107
1108                                 int check_size = 5;
1109                                 int lineWidth = 3;
1110
1111                                 Rectangle rect = new Rectangle (x + 5, middle - 2, check_size, check_size);
1112
1113                                 for (int i = 0; i < lineWidth; i++) {
1114                                         dc.DrawLine (check_pen, rect.Left + 1, rect.Top + lineWidth + i, rect.Left + 3, rect.Top + 5 + i);
1115                                         dc.DrawLine (check_pen, rect.Left + 3, rect.Top + 5 + i, rect.Left + 7, rect.Top + 1 + i);
1116                                 }
1117                         }
1118                 }
1119
1120                 private void DrawNodeLines (TreeNode node, Graphics dc, Rectangle clip, Pen dash, int x, int y, int middle)
1121                 {
1122                         int ladjust = 9;
1123                         int radjust = 0;
1124
1125                         if (node.nodes.Count > 0 && show_plus_minus)
1126                                 ladjust = 13;
1127                         if (checkboxes)
1128                                 radjust = 3;
1129
1130                         dc.DrawLine (dash, x - indent + ladjust, middle, x + radjust, middle);
1131
1132                         if (node.PrevNode != null || node.Parent != null) {
1133                                 ladjust = 9;
1134                                 dc.DrawLine (dash, x - indent + ladjust, node.Bounds.Top,
1135                                                 x - indent + ladjust, middle - (show_plus_minus && node.Nodes.Count > 0 ? 4 : 0));
1136                         }
1137
1138                         if (node.NextNode != null) {
1139                                 ladjust = 9;
1140                                 dc.DrawLine (dash, x - indent + ladjust, middle + (show_plus_minus && node.Nodes.Count > 0 ? 4 : 0),
1141                                                 x - indent + ladjust, node.Bounds.Bottom);
1142
1143                         }
1144
1145                         ladjust = 0;
1146                         if (show_plus_minus)
1147                                 ladjust = 9;
1148                         TreeNode parent = node.Parent;
1149                         while (parent != null) {
1150                                 if (parent.NextNode != null) {
1151                                         int px = parent.GetLinesX () - indent + ladjust;
1152                                         dc.DrawLine (dash, px, node.Bounds.Top, px, node.Bounds.Bottom);
1153                                 }
1154                                 parent = parent.Parent;
1155                         }
1156                 }
1157
1158                 private void DrawNodeImage (TreeNode node, Graphics dc, Rectangle clip, int x, int y)
1159                 {
1160                         // Rectangle r = new Rectangle (x, y + 2, ImageList.ImageSize.Width, ImageList.ImageSize.Height);
1161
1162                         if (!RectsIntersect (clip, x, y + 2, ImageList.ImageSize.Width, ImageList.ImageSize.Height))
1163                                 return;
1164
1165                         if (ImageList == null)
1166                                 return;
1167
1168                         int use_index = -1;
1169                         if (node.ImageIndex > -1 && node.ImageIndex < ImageList.Images.Count) {
1170                                 use_index = node.ImageIndex;
1171                         } else if (ImageIndex > -1 && ImageIndex < ImageList.Images.Count) {
1172                                 use_index = ImageIndex;
1173                         }
1174
1175                         if (use_index == -1 && ImageList.Images.Count > 0) {
1176                                 use_index = 0;
1177                         }
1178
1179                         if (use_index != -1) {
1180                                 ImageList.Draw (dc, x, y + 2, ImageList.ImageSize.Width,
1181                                                 ImageList.ImageSize.Height, use_index);
1182                         }
1183                 }
1184
1185                 private void LabelEditFinished (object sender, EventArgs e)
1186                 {
1187                         EndEdit (edit_node);
1188                 }
1189
1190                 internal void BeginEdit (TreeNode node)
1191                 {
1192                         if (edit_node != null)
1193                                 EndEdit (edit_node);
1194
1195                         if (edit_text_box == null) {
1196                                 edit_text_box = new LabelEditTextBox ();
1197                                 edit_text_box.BorderStyle = BorderStyle.FixedSingle;
1198                                 edit_text_box.EditingFinished += new EventHandler (LabelEditFinished);
1199                                 Controls.Add (edit_text_box);
1200                         }
1201
1202                         edit_text_box.Bounds = node.Bounds;
1203                         edit_text_box.Width += 4;
1204
1205                         edit_text_box.Text = node.Text;
1206                         edit_text_box.Visible = true;
1207                         edit_text_box.Focus ();
1208                         edit_text_box.SelectAll ();
1209
1210                         edit_args = new NodeLabelEditEventArgs (edit_node);
1211                         OnBeforeLabelEdit (edit_args);
1212
1213                         if (edit_args.CancelEdit)
1214                                 EndEdit (node);
1215
1216                         edit_node = node;
1217                 }
1218
1219                 internal void EndEdit (TreeNode node)
1220                 {
1221                         if (edit_text_box != null && edit_text_box.Visible) {
1222                                 edit_text_box.Visible = false;
1223                         }
1224
1225                         if (edit_node != null && edit_node == node) {
1226                                 OnAfterLabelEdit (edit_args);
1227
1228                                 if (!edit_args.CancelEdit) {
1229                                         if (edit_args.Label != null)
1230                                                 edit_node.Text = edit_args.Label;
1231                                         else
1232                                                 edit_node.Text = edit_text_box.Text;
1233                                 }
1234
1235                         }
1236
1237
1238                         edit_node = null;
1239                         UpdateNode (node);
1240                 }
1241
1242                 internal int GetNodeWidth (TreeNode node)
1243                 {
1244                         Font font = node.NodeFont;
1245                         if (node.NodeFont == null)
1246                                 font = Font;
1247                         return (int) DeviceContext.MeasureString (node.Text, font, 0, string_format).Width + 3;
1248                 }
1249
1250                 private void DrawSelectionAndFocus(TreeNode node, Graphics dc, Rectangle r)
1251                 {
1252                         if (Focused && focused_node == node) {
1253                                 ControlPaint.DrawFocusRectangle (dc, r, ForeColor, BackColor);
1254                         }
1255                         r.Inflate(-1, -1);
1256                         if (Focused && node == highlighted_node) {
1257                                 dc.FillRectangle (ThemeEngine.Current.ResPool.GetSolidBrush (ThemeEngine.Current.ColorHighlight), r);
1258                         } else if (!hide_selection && node == highlighted_node) {
1259                                 dc.FillRectangle (SystemBrushes.Control, r);
1260                         } else {
1261                                 dc.FillRectangle (ThemeEngine.Current.ResPool.GetSolidBrush (node.BackColor), r);
1262                         }
1263                 }
1264
1265                 private void DrawStaticNode (TreeNode node, Graphics dc)
1266                 {
1267                         if (!full_row_select)
1268                                 DrawSelectionAndFocus(node, dc, node.Bounds);
1269
1270                         Font font = node.NodeFont;
1271                         if (node.NodeFont == null)
1272                                 font = Font;
1273                         Color text_color = (Focused && node == highlighted_node ?
1274                                         ThemeEngine.Current.ColorHighlightText : node.ForeColor);
1275                         dc.DrawString (node.Text, font,
1276                                         ThemeEngine.Current.ResPool.GetSolidBrush (text_color),
1277                                         node.Bounds, string_format);
1278                 }
1279
1280                 private void DrawNode (TreeNode node, Graphics dc, Rectangle clip)
1281                 {
1282                         int child_count = node.nodes.Count;
1283                         int y = node.GetY ();
1284                         int middle = y + (ActualItemHeight / 2);
1285
1286                         if (full_row_select) {
1287                                 Rectangle r = new Rectangle (1, y + 2, ViewportRectangle.Width - 2, ActualItemHeight);
1288                                 DrawSelectionAndFocus (node, dc, r);
1289                         }
1290
1291                         if ((show_root_lines || node.Parent != null) && show_plus_minus && child_count > 0)
1292                                 DrawNodePlusMinus (node, dc, node.GetLinesX () - Indent + 5, middle);
1293
1294                         if (checkboxes)
1295                                 DrawNodeCheckBox (node, dc, CheckBoxLeft (node) - 3, middle);
1296
1297                         if (show_lines)
1298                                 DrawNodeLines (node, dc, clip, dash, node.GetLinesX (), y, middle);
1299
1300                         if (ImageList != null)
1301                                 DrawNodeImage (node, dc, clip, node.GetImageX (), y);
1302
1303                         if (!node.IsEditing)
1304                                 DrawStaticNode (node, dc);
1305                 }
1306
1307                 internal void UpdateScrollBars ()
1308                 {
1309                         if (IsDisposed || update_stack > 0 || !IsHandleCreated || !Visible)
1310                                 return;
1311
1312                         bool vert = false;
1313                         bool horz = false;
1314                         int height = -1;
1315                         int width = -1;
1316
1317                         if (scrollable) {
1318                                 OpenTreeNodeEnumerator walk = new OpenTreeNodeEnumerator (root_node);
1319
1320                                 while (walk.MoveNext ()) {
1321                                         int r = walk.CurrentNode.Bounds.Right;
1322                                         int b = walk.CurrentNode.Bounds.Bottom;
1323
1324                                         if (r > width)
1325                                                 width = r;
1326                                         if (b > height)
1327                                                 height = b;
1328                                 }
1329
1330                                 // Remove scroll adjustments
1331                                 if (nodes.Count > 0)
1332                                         height -= nodes [0].Bounds.Top;
1333                                 width += hbar_offset;
1334
1335                                 if (height > ClientRectangle.Height) {
1336                                         vert = true;
1337
1338                                         if (width > ClientRectangle.Width - SystemInformation.VerticalScrollBarWidth)
1339                                                 horz = true;
1340                                 } else if (width > ClientRectangle.Width) {
1341                                         horz = true;
1342                                 }
1343
1344                                 if (!vert && horz && height > ClientRectangle.Height - SystemInformation.HorizontalScrollBarHeight)
1345                                         vert = true;
1346                         }
1347
1348                         if (vert) {
1349                                 int visible_height = horz ? ClientRectangle.Height - hbar.Height : ClientRectangle.Height;
1350                                 vbar.SetValues (Math.Max (0, max_visible_order - 2), visible_height / ActualItemHeight);
1351                                 /*
1352                                 vbar.Maximum = max_visible_order;
1353                                 vbar.LargeChange = ClientRectangle.Height / ItemHeight;
1354                                 */
1355
1356                                 if (!vbar_bounds_set) {
1357                                         vbar.Bounds = new Rectangle (ClientRectangle.Width - vbar.Width, 0, vbar.Width,
1358                                                         ClientRectangle.Height -
1359                                                         (horz ? SystemInformation.VerticalScrollBarWidth : 0));
1360                                         vbar_bounds_set = true;
1361
1362                                         // We need to recalc the hbar if the vbar is now visible
1363                                         hbar_bounds_set = false;
1364                                 }
1365
1366                                 vbar.Visible = true;
1367                         } else {
1368                                 skipped_nodes = 0;
1369                                 top_node = root_node.FirstNode;
1370                                 RecalculateVisibleOrder (root_node);
1371                                 vbar.Visible = false;
1372                                 vbar_bounds_set = false;
1373                         }
1374
1375                         if (horz) {
1376                                 hbar.SetValues (width + 1, ClientRectangle.Width);
1377                                 /*
1378                                 hbar.LargeChange = ClientRectangle.Width;
1379                                 hbar.Maximum = width + 1;
1380                                 */
1381
1382                                 if (!hbar_bounds_set) {
1383                                         hbar.Bounds = new Rectangle (0, ClientRectangle.Height - hbar.Height,
1384                                                         ClientRectangle.Width - (vert ? SystemInformation.VerticalScrollBarWidth : 0),
1385                                                         hbar.Height);
1386                                         hbar_bounds_set = true;
1387                                 }
1388                                 hbar.Visible = true;
1389                         } else {
1390                                 hbar_offset = 0;
1391                                 hbar.Visible = false;
1392                                 hbar_bounds_set = false;
1393                         }
1394                 }
1395
1396                 private void SizeChangedHandler (object sender, EventArgs e)
1397                 {
1398                         if (IsHandleCreated) {
1399                                 if (max_visible_order == -1)
1400                                         RecalculateVisibleOrder (root_node);
1401                                 UpdateScrollBars ();
1402                         }
1403
1404                         if (vbar.Visible) {
1405                                 vbar.Bounds = new Rectangle (ClientRectangle.Width - vbar.Width, 0, vbar.Width,
1406                                                 ClientRectangle.Height - (hbar.Visible ? SystemInformation.HorizontalScrollBarHeight : 0));
1407                         }
1408
1409                         if (hbar.Visible) {
1410                                 hbar.Bounds = new Rectangle (0, ClientRectangle.Height - hbar.Height,
1411                                                 ClientRectangle.Width - (vbar.Visible ? SystemInformation.VerticalScrollBarWidth : 0), hbar.Height);
1412                         }
1413                 }
1414
1415                 private void VScrollBarValueChanged (object sender, EventArgs e)
1416                 {
1417                         EndEdit (edit_node);
1418
1419                         SetVScrollPos (vbar.Value, null);
1420                 }
1421
1422                 private void SetVScrollPos (int pos, TreeNode new_top)
1423                 {
1424                         if (pos < 0)
1425                                 pos = 0;
1426
1427                         if (skipped_nodes == pos)
1428                                 return;
1429
1430                         int old_skip = skipped_nodes;
1431                         skipped_nodes = pos;
1432                         int diff = old_skip - skipped_nodes;
1433
1434                         // Determine the new top node if we have to
1435                         if (new_top == null) {
1436                                 if (top_node == null)
1437                                         top_node = nodes [0];
1438
1439                                 OpenTreeNodeEnumerator walk = new OpenTreeNodeEnumerator (TopNode);
1440                                 if (diff < 0) {
1441                                         for (int i = diff; i <= 0; i++)
1442                                                 walk.MoveNext ();
1443                                         new_top = walk.CurrentNode;
1444                                 } else {
1445                                         for (int i = 0; i <= diff; i++)
1446                                                 walk.MovePrevious ();
1447                                         new_top = walk.CurrentNode;
1448                                 }
1449                         }
1450
1451                         top_node = new_top;
1452                         int y_move = diff * ActualItemHeight;
1453                         XplatUI.ScrollWindow (Handle, ViewportRectangle, 0, y_move, false);
1454                 }
1455
1456                 private void SetVScrollTop (TreeNode new_top)
1457                 {
1458                         OpenTreeNodeEnumerator walk = new OpenTreeNodeEnumerator (root_node);
1459
1460                         skipped_nodes = -1;
1461                         while (walk.MoveNext () && walk.CurrentNode != new_top)
1462                                 skipped_nodes++;
1463
1464                         top_node = new_top;
1465                         vbar.Value = skipped_nodes;
1466                 }
1467
1468                 private void HScrollBarValueChanged(object sender, EventArgs e)
1469                 {
1470                         EndEdit (edit_node);
1471
1472                         int old_offset = hbar_offset;
1473                         hbar_offset = hbar.Value;
1474
1475                         if (hbar_offset < 0) {
1476                                 hbar_offset = 0;
1477                         }
1478
1479                         XplatUI.ScrollWindow (Handle, ViewportRectangle, old_offset - hbar_offset, 0, false);
1480                 }
1481
1482                 internal void ExpandBelow (TreeNode node, int count_to_next)
1483                 {
1484                         if (update_stack > 0) {
1485                                 update_needed = true;
1486                                 return;
1487                         }
1488
1489                         Rectangle below = new Rectangle (0, node.Bounds.Bottom + 2, ViewportRectangle.Width,
1490                                         ViewportRectangle.Height - node.Bounds.Bottom);
1491
1492                         int amount = count_to_next * ActualItemHeight;
1493
1494                         if (amount > 0)
1495                                 XplatUI.ScrollWindow (Handle, below, 0, amount, false);
1496
1497                         if (show_plus_minus) {
1498                                 //int linesx = node.GetLinesX ();
1499                                 Invalidate (new Rectangle (0, node.GetY (), Width, ActualItemHeight));
1500                         }
1501                 }
1502
1503                 internal void CollapseBelow (TreeNode node, int count_to_next)
1504                 {
1505                         if (update_stack > 0) {
1506                                 update_needed = true;
1507                                 return;
1508                         }
1509
1510                         Rectangle below = new Rectangle (0, node.Bounds.Bottom + 2, ViewportRectangle.Width,
1511                                         ViewportRectangle.Height - node.Bounds.Bottom + 2);
1512
1513                         int amount = count_to_next * ActualItemHeight;
1514
1515                         if (amount > 0)
1516                                 XplatUI.ScrollWindow (Handle, below, 0, -amount, false);
1517
1518                         if (show_plus_minus) {
1519                                 //int linesx = node.GetLinesX ();
1520                                 Invalidate (new Rectangle (0, node.GetY (), Width, ActualItemHeight));
1521                         }
1522                 }
1523
1524                 private void MouseWheelHandler(object sender, MouseEventArgs e) {
1525
1526                         if (vbar == null || !vbar.Visible) {
1527                                 return;
1528                         }
1529
1530                         if (e.Delta < 0) {
1531                                 vbar.Value = Math.Min(vbar.Value + SystemInformation.MouseWheelScrollLines, vbar.Maximum - VisibleCount + 1);
1532                         } else {
1533                                 vbar.Value = Math.Max(0, vbar.Value - SystemInformation.MouseWheelScrollLines);
1534                         }
1535                 }
1536
1537                 private void FontChangedHandler (object sender, EventArgs e)
1538                 {
1539                         InvalidateNodeWidthRecursive (root_node);
1540                 }
1541
1542                 private void InvalidateNodeWidthRecursive (TreeNode node)
1543                 {
1544                         node.InvalidateWidth ();
1545                         foreach (TreeNode child in node.Nodes) {
1546                                 InvalidateNodeWidthRecursive (child);
1547                         }
1548                 }
1549
1550                 private void GotFocusHandler (object sender, EventArgs e)
1551                 {
1552                         if (selected_node == null)
1553                                 SelectedNode = top_node;
1554                         else
1555                                 UpdateNode (selected_node);
1556                 }
1557
1558                 private void LostFocusHandler (object sender, EventArgs e)
1559                 {
1560                         UpdateNode (SelectedNode);
1561                 }
1562
1563                 private void MouseDownHandler (object sender, MouseEventArgs e)
1564                 {
1565                         if (e.Button == MouseButtons.Right)
1566                                 Focus ();
1567
1568                         TreeNode node = GetNodeAt (e.Y);
1569                         if (node == null)
1570                                 return;
1571
1572                         if (show_plus_minus && IsPlusMinusArea (node, e.X)) {
1573                                 node.Toggle ();
1574                                 return;
1575                         } else if (checkboxes && IsCheckboxArea (node, e.X)) {
1576                                 node.check_reason = TreeViewAction.ByMouse;
1577                                 node.Checked = !node.Checked;
1578                                 UpdateNode(node);
1579                                 return;
1580                         } else if (IsSelectableArea (node, e.X) || full_row_select) {
1581                                 TreeNode old_highlighted = highlighted_node;
1582                                 highlighted_node = node;
1583                                 if (label_edit && e.Clicks == 1 && highlighted_node == old_highlighted) {
1584                                         BeginEdit (node);
1585                                 } else if (highlighted_node != focused_node) {
1586                                         Size ds = SystemInformation.DragSize;
1587                                         mouse_rect.X = e.X - ds.Width;
1588                                         mouse_rect.Y = e.Y - ds.Height;
1589                                         mouse_rect.Width = ds.Width * 2;
1590                                         mouse_rect.Height = ds.Height * 2;
1591
1592                                         select_mmove = true;
1593                                 }
1594
1595                                 Invalidate (highlighted_node.Bounds);
1596                                 if (old_highlighted != null)
1597                                         Invalidate (Bloat (old_highlighted.Bounds));
1598                         }
1599                 }
1600
1601                 private void MouseUpHandler (object sender, MouseEventArgs e) {
1602
1603                         drag_begin_x = -1;
1604                         drag_begin_y = -1;
1605
1606                         if (!select_mmove)
1607                                 return;
1608
1609                         if (e.Button == MouseButtons.Right) {
1610                                 Invalidate (highlighted_node.Bounds);
1611                                 highlighted_node = selected_node;
1612                                 Invalidate (selected_node.Bounds);
1613                         }
1614                         select_mmove = false;
1615
1616                         TreeViewCancelEventArgs ce = new TreeViewCancelEventArgs (highlighted_node, false, TreeViewAction.ByMouse);
1617                         OnBeforeSelect (ce);
1618
1619                         Rectangle invalid;
1620                         if (!ce.Cancel) {
1621                                 if (focused_node != null) {
1622                                         invalid = Rectangle.Union (Bloat (focused_node.Bounds),
1623                                                         Bloat (highlighted_node.Bounds));
1624                                 } else {
1625                                         invalid = Bloat (highlighted_node.Bounds);
1626                                 }
1627                                 selected_node = highlighted_node;
1628                                 focused_node = highlighted_node;
1629                                 OnAfterSelect (new TreeViewEventArgs (selected_node, TreeViewAction.ByMouse));
1630
1631                                 Invalidate (invalid);
1632                         } else {
1633                                 highlighted_node = focused_node;
1634                                 selected_node = focused_node;
1635                         }
1636                 }
1637
1638                 private void MouseMoveHandler (object sender, MouseEventArgs e) {
1639
1640                         if (e.Button == MouseButtons.Left || e.Button == MouseButtons.Right) {
1641                                 if (drag_begin_x == -1 && drag_begin_y == -1) {
1642                                         drag_begin_x = e.X;
1643                                         drag_begin_y = e.Y;
1644                                 } else {
1645                                         double rise = Math.Pow (drag_begin_x - e.X, 2);
1646                                         double run = Math.Pow (drag_begin_y - e.Y, 2);
1647                                         double move = Math.Sqrt (rise + run);
1648                                         if (move > 3) {
1649                                                 TreeNode drag = GetNodeAtUseX (e.X, e.Y);
1650
1651                                                 if (drag != null) {
1652                                                         OnItemDrag (new ItemDragEventArgs (e.Button, drag));
1653                                                 }
1654                                                 drag_begin_x = -1;
1655                                                 drag_begin_y = -1;
1656                                         }
1657                                 }
1658
1659                         }
1660
1661                         // If there is enough movement before the mouse comes up,
1662                         // selection is reverted back to the originally selected node
1663                         if (!select_mmove || mouse_rect.Contains (e.X, e.Y))
1664                                 return;
1665
1666                         Invalidate (highlighted_node.Bounds);
1667                         Invalidate (selected_node.Bounds);
1668                         Invalidate (focused_node.Bounds);
1669
1670                         highlighted_node = selected_node;
1671                         focused_node = selected_node;
1672
1673                         select_mmove = false;
1674                 }
1675
1676                 private void DoubleClickHandler (object sender, MouseEventArgs e) {
1677                         TreeNode node = GetNodeAtUseX (e.X,e.Y);
1678                         if(node != null) {
1679                                 node.Toggle();
1680                         }
1681                 }
1682
1683
1684                 private bool RectsIntersect (Rectangle r, int left, int top, int width, int height)
1685                 {
1686                         return !((r.Left > left + width) || (r.Right < left) ||
1687                                         (r.Top > top + height) || (r.Bottom < top));
1688                 }
1689
1690                 #endregion      // Internal & Private Methods and Properties
1691
1692                 #region Events
1693                 static object ItemDragEvent = new object ();
1694                 static object AfterCheckEvent = new object ();
1695                 static object AfterCollapseEvent = new object ();
1696                 static object AfterExpandEvent = new object ();
1697                 static object AfterLabelEditEvent = new object ();
1698                 static object AfterSelectEvent = new object ();
1699                 static object BeforeCheckEvent = new object ();
1700                 static object BeforeCollapseEvent = new object ();
1701                 static object BeforeExpandEvent = new object ();
1702                 static object BeforeLabelEditEvent = new object ();
1703                 static object BeforeSelectEvent = new object ();
1704
1705                 public event ItemDragEventHandler ItemDrag {
1706                         add { Events.AddHandler (ItemDragEvent, value); }
1707                         remove { Events.RemoveHandler (ItemDragEvent, value); }
1708                 }
1709
1710                 public event TreeViewEventHandler AfterCheck {
1711                         add { Events.AddHandler (AfterCheckEvent, value); }
1712                         remove { Events.RemoveHandler (AfterCheckEvent, value); }
1713                 }
1714
1715                 public event TreeViewEventHandler AfterCollapse {
1716                         add { Events.AddHandler (AfterCollapseEvent, value); }
1717                         remove { Events.RemoveHandler (AfterCollapseEvent, value); }
1718                 }
1719
1720                 public event TreeViewEventHandler AfterExpand {
1721                         add { Events.AddHandler (AfterExpandEvent, value); }
1722                         remove { Events.RemoveHandler (AfterExpandEvent, value); }
1723                 }
1724
1725                 public event NodeLabelEditEventHandler AfterLabelEdit {
1726                         add { Events.AddHandler (AfterLabelEditEvent, value); }
1727                         remove { Events.RemoveHandler (AfterLabelEditEvent, value); }
1728                 }
1729
1730                 public event TreeViewEventHandler AfterSelect {
1731                         add { Events.AddHandler (AfterSelectEvent, value); }
1732                         remove { Events.RemoveHandler (AfterSelectEvent, value); }
1733                 }
1734
1735                 public event TreeViewCancelEventHandler BeforeCheck {
1736                         add { Events.AddHandler (BeforeCheckEvent, value); }
1737                         remove { Events.RemoveHandler (BeforeCheckEvent, value); }
1738                 }
1739
1740                 public event TreeViewCancelEventHandler BeforeCollapse {
1741                         add { Events.AddHandler (BeforeCollapseEvent, value); }
1742                         remove { Events.RemoveHandler (BeforeCollapseEvent, value); }
1743                 }
1744
1745                 public event TreeViewCancelEventHandler BeforeExpand {
1746                         add { Events.AddHandler (BeforeExpandEvent, value); }
1747                         remove { Events.RemoveHandler (BeforeExpandEvent, value); }
1748                 }
1749
1750                 public event NodeLabelEditEventHandler BeforeLabelEdit {
1751                         add { Events.AddHandler (BeforeLabelEditEvent, value); }
1752                         remove { Events.RemoveHandler (BeforeLabelEditEvent, value); }
1753                 }
1754
1755                 public event TreeViewCancelEventHandler BeforeSelect {
1756                         add { Events.AddHandler (BeforeSelectEvent, value); }
1757                         remove { Events.RemoveHandler (BeforeSelectEvent, value); }
1758                 }
1759
1760                 [Browsable (false)]
1761                 [EditorBrowsable (EditorBrowsableState.Never)]
1762                 public new event EventHandler BackgroundImageChanged {
1763                         add { base.BackgroundImageChanged += value; }
1764                         remove { base.BackgroundImageChanged -= value; }
1765                 }
1766
1767                 [EditorBrowsable (EditorBrowsableState.Never)]
1768                 [Browsable (false)]
1769                 public new event PaintEventHandler Paint {
1770                         add { base.Paint += value; }
1771                         remove { base.Paint -= value; }
1772                 }
1773
1774                 [EditorBrowsable (EditorBrowsableState.Never)]
1775                 [Browsable (false)]
1776                 public new event EventHandler TextChanged {
1777                         add { base.TextChanged += value; }
1778                         remove { base.TextChanged -= value; }
1779                 }
1780                 #endregion      // Events
1781         }
1782 }
1783