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