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