mcs/class/Managed.Windows.Forms/System.Windows.Forms/ListView.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. (http://www.novell.com)
  21 //
  22 // Authors:
  23 //      Ravindra Kumar (rkumar@novell.com)
  24 //      Jordi Mas i Hernandez, jordi@ximian.com
  25 //      Mike Kestner (mkestner@novell.com)
  26 //      Daniel Nauck (dna(at)mono-project(dot)de)
  27 //      Carlos Alberto Cortez <calberto.cortez@gmail.com>
  28 //
  29
  30
  31 // NOT COMPLETE
  32
  33
  34 using System.Collections;
  35 using System.ComponentModel;
  36 using System.ComponentModel.Design;
  37 using System.Drawing;
  38 using System.Runtime.InteropServices;
  39 using System.Globalization;
  40 using System.Collections.Generic;
  41
  42 namespace System.Windows.Forms
  43 {
  44         [DefaultEvent ("SelectedIndexChanged")]
  45         [DefaultProperty ("Items")]
  46         [Designer ("System.Windows.Forms.Design.ListViewDesigner, " + Consts.AssemblySystem_Design, "System.ComponentModel.Design.IDesigner")]
  47         [ClassInterface (ClassInterfaceType.AutoDispatch)]
  48         [ComVisible (true)]
  49         [Docking (DockingBehavior.Ask)]
  50         public class ListView : Control
  51         {
  52                 private ItemActivation activation = ItemActivation.Standard;
  53                 private ListViewAlignment alignment = ListViewAlignment.Top;
  54                 private bool allow_column_reorder;
  55                 private bool auto_arrange = true;
  56                 private bool check_boxes;
  57                 private readonly CheckedIndexCollection checked_indices;
  58                 private readonly CheckedListViewItemCollection checked_items;
  59                 private readonly ColumnHeaderCollection columns;
  60                 internal int focused_item_index = -1;
  61                 private bool full_row_select;
  62                 private bool grid_lines;
  63                 private ColumnHeaderStyle header_style = ColumnHeaderStyle.Clickable;
  64                 private bool hide_selection = true;
  65                 private bool hover_selection;
  66                 private IComparer item_sorter;
  67                 private readonly ListViewItemCollection items;
  68                 private readonly ListViewGroupCollection groups;
  69                 private bool owner_draw;
  70                 private bool show_groups = true;
  71                 private bool label_edit;
  72                 private bool label_wrap = true;
  73                 private bool multiselect = true;
  74                 private bool scrollable = true;
  75                 private bool hover_pending;
  76                 private readonly SelectedIndexCollection selected_indices;
  77                 private readonly SelectedListViewItemCollection selected_items;
  78                 private SortOrder sort_order = SortOrder.None;
  79                 private ImageList state_image_list;
  80                 internal bool updating;
  81                 private View view = View.LargeIcon;
  82                 private int layout_wd;    // We might draw more than our client area
  83                 private int layout_ht;    // therefore we need to have these two.
  84                 internal HeaderControl header_control;
  85                 internal ItemControl item_control;
  86                 internal ScrollBar h_scroll; // used for scrolling horizontally
  87                 internal ScrollBar v_scroll; // used for scrolling vertically
  88                 internal int h_marker;          // Position markers for scrolling
  89                 internal int v_marker;
  90                 private int keysearch_tickcnt;
  91                 private string keysearch_text;
  92                 static private readonly int keysearch_keydelay = 1000;
  93                 private int[] reordered_column_indices;
  94                 private int[] reordered_items_indices;
  95                 private Point [] items_location;
  96                 private ItemMatrixLocation [] items_matrix_location;
  97                 private Size item_size; // used for caching item size
  98                 private int custom_column_width; // used when using Columns with SmallIcon/List views
  99                 private int hot_item_index = -1;
 100                 private bool hot_tracking;
 101                 private ListViewInsertionMark insertion_mark;
 102                 private bool show_item_tooltips;
 103                 private ToolTip item_tooltip;
 104                 private Size tile_size;
 105                 private bool virtual_mode;
 106                 private int virtual_list_size;
 107                 private bool right_to_left_layout;
 108                 // selection is available after the first time the handle is created, *even* if later
 109                 // the handle is either recreated or destroyed - so keep this info around.
 110                 private bool is_selection_available;
 111
 112                 // internal variables
 113                 internal ImageList large_image_list;
 114                 internal ImageList small_image_list;
 115                 internal Size text_size = Size.Empty;
 116
 117                 #region Events
 118                 static object AfterLabelEditEvent = new object ();
 119                 static object BeforeLabelEditEvent = new object ();
 120                 static object ColumnClickEvent = new object ();
 121                 static object ItemActivateEvent = new object ();
 122                 static object ItemCheckEvent = new object ();
 123                 static object ItemDragEvent = new object ();
 124                 static object SelectedIndexChangedEvent = new object ();
 125                 static object DrawColumnHeaderEvent = new object();
 126                 static object DrawItemEvent = new object();
 127                 static object DrawSubItemEvent = new object();
 128                 static object ItemCheckedEvent = new object ();
 129                 static object ItemMouseHoverEvent = new object ();
 130                 static object ItemSelectionChangedEvent = new object ();
 131                 static object CacheVirtualItemsEvent = new object ();
 132                 static object RetrieveVirtualItemEvent = new object ();
 133                 static object RightToLeftLayoutChangedEvent = new object ();
 134                 static object SearchForVirtualItemEvent = new object ();
 135                 static object VirtualItemsSelectionRangeChangedEvent = new object ();
 136
 137                 public event LabelEditEventHandler AfterLabelEdit {
 138                         add { Events.AddHandler (AfterLabelEditEvent, value); }
 139                         remove { Events.RemoveHandler (AfterLabelEditEvent, value); }
 140                 }
 141
 142
 143                 [Browsable (false)]
 144                 [EditorBrowsable (EditorBrowsableState.Never)]
 145                 public new event EventHandler BackgroundImageLayoutChanged {
 146                         add { base.BackgroundImageLayoutChanged += value; }
 147                         remove { base.BackgroundImageLayoutChanged -= value; }
 148                 }
 149
 150                 public event LabelEditEventHandler BeforeLabelEdit {
 151                         add { Events.AddHandler (BeforeLabelEditEvent, value); }
 152                         remove { Events.RemoveHandler (BeforeLabelEditEvent, value); }
 153                 }
 154
 155                 public event ColumnClickEventHandler ColumnClick {
 156                         add { Events.AddHandler (ColumnClickEvent, value); }
 157                         remove { Events.RemoveHandler (ColumnClickEvent, value); }
 158                 }
 159
 160                 public event DrawListViewColumnHeaderEventHandler DrawColumnHeader {
 161                         add { Events.AddHandler(DrawColumnHeaderEvent, value); }
 162                         remove { Events.RemoveHandler(DrawColumnHeaderEvent, value); }
 163                 }
 164
 165                 public event DrawListViewItemEventHandler DrawItem {
 166                         add { Events.AddHandler(DrawItemEvent, value); }
 167                         remove { Events.RemoveHandler(DrawItemEvent, value); }
 168                 }
 169
 170                 public event DrawListViewSubItemEventHandler DrawSubItem {
 171                         add { Events.AddHandler(DrawSubItemEvent, value); }
 172                         remove { Events.RemoveHandler(DrawSubItemEvent, value); }
 173                 }
 174
 175                 public event EventHandler ItemActivate {
 176                         add { Events.AddHandler (ItemActivateEvent, value); }
 177                         remove { Events.RemoveHandler (ItemActivateEvent, value); }
 178                 }
 179
 180                 public event ItemCheckEventHandler ItemCheck {
 181                         add { Events.AddHandler (ItemCheckEvent, value); }
 182                         remove { Events.RemoveHandler (ItemCheckEvent, value); }
 183                 }
 184
 185                 public event ItemCheckedEventHandler ItemChecked {
 186                         add { Events.AddHandler (ItemCheckedEvent, value); }
 187                         remove { Events.RemoveHandler (ItemCheckedEvent, value); }
 188                 }
 189
 190                 public event ItemDragEventHandler ItemDrag {
 191                         add { Events.AddHandler (ItemDragEvent, value); }
 192                         remove { Events.RemoveHandler (ItemDragEvent, value); }
 193                 }
 194
 195                 public event ListViewItemMouseHoverEventHandler ItemMouseHover {
 196                         add { Events.AddHandler (ItemMouseHoverEvent, value); }
 197                         remove { Events.RemoveHandler (ItemMouseHoverEvent, value); }
 198                 }
 199
 200                 public event ListViewItemSelectionChangedEventHandler ItemSelectionChanged {
 201                         add { Events.AddHandler (ItemSelectionChangedEvent, value); }
 202                         remove { Events.RemoveHandler (ItemSelectionChangedEvent, value); }
 203                 }
 204
 205                 [Browsable (false)]
 206                 [EditorBrowsable (EditorBrowsableState.Never)]
 207                 public new event EventHandler PaddingChanged {
 208                         add { base.PaddingChanged += value; }
 209                         remove { base.PaddingChanged -= value; }
 210                 }
 211
 212                 [Browsable (false)]
 213                 [EditorBrowsable (EditorBrowsableState.Never)]
 214                 public new event PaintEventHandler Paint {
 215                         add { base.Paint += value; }
 216                         remove { base.Paint -= value; }
 217                 }
 218
 219                 public event EventHandler SelectedIndexChanged {
 220                         add { Events.AddHandler (SelectedIndexChangedEvent, value); }
 221                         remove { Events.RemoveHandler (SelectedIndexChangedEvent, value); }
 222                 }
 223
 224                 [Browsable (false)]
 225                 [EditorBrowsable (EditorBrowsableState.Never)]
 226                 public new event EventHandler TextChanged {
 227                         add { base.TextChanged += value; }
 228                         remove { base.TextChanged -= value; }
 229                 }
 230
 231                 public event CacheVirtualItemsEventHandler CacheVirtualItems {
 232                         add { Events.AddHandler (CacheVirtualItemsEvent, value); }
 233                         remove { Events.RemoveHandler (CacheVirtualItemsEvent, value); }
 234                 }
 235
 236                 public event RetrieveVirtualItemEventHandler RetrieveVirtualItem {
 237                         add { Events.AddHandler (RetrieveVirtualItemEvent, value); }
 238                         remove { Events.RemoveHandler (RetrieveVirtualItemEvent, value); }
 239                 }
 240
 241                 public event EventHandler RightToLeftLayoutChanged {
 242                         add { Events.AddHandler (RightToLeftLayoutChangedEvent, value); }
 243                         remove { Events.RemoveHandler (RightToLeftLayoutChangedEvent, value); }
 244                 }
 245
 246                 public event SearchForVirtualItemEventHandler SearchForVirtualItem {
 247                         add { Events.AddHandler (SearchForVirtualItemEvent, value); }
 248                         remove { Events.AddHandler (SearchForVirtualItemEvent, value); }
 249                 }
 250
 251                 public event ListViewVirtualItemsSelectionRangeChangedEventHandler VirtualItemsSelectionRangeChanged {
 252                         add { Events.AddHandler (VirtualItemsSelectionRangeChangedEvent, value); }
 253                         remove { Events.RemoveHandler (VirtualItemsSelectionRangeChangedEvent, value); }
 254                 }
 255
 256                 #endregion // Events
 257
 258                 #region Public Constructors
 259                 public ListView ()
 260                 {
 261                         background_color = ThemeEngine.Current.ColorWindow;
 262                         groups = new ListViewGroupCollection (this);
 263                         items = new ListViewItemCollection (this);
 264                         items.Changed += new CollectionChangedHandler (OnItemsChanged);
 265                         checked_indices = new CheckedIndexCollection (this);
 266                         checked_items = new CheckedListViewItemCollection (this);
 267                         columns = new ColumnHeaderCollection (this);
 268                         foreground_color = SystemColors.WindowText;
 269                         selected_indices = new SelectedIndexCollection (this);
 270                         selected_items = new SelectedListViewItemCollection (this);
 271                         items_location = new Point [16];
 272                         items_matrix_location = new ItemMatrixLocation [16];
 273                         reordered_items_indices = new int [16];
 274                         item_tooltip = new ToolTip ();
 275                         item_tooltip.Active = false;
 276                         insertion_mark = new ListViewInsertionMark (this);
 277
 278                         InternalBorderStyle = BorderStyle.Fixed3D;
 279
 280                         header_control = new HeaderControl (this);
 281                         header_control.Visible = false;
 282                         Controls.AddImplicit (header_control);
 283
 284                         item_control = new ItemControl (this);
 285                         Controls.AddImplicit (item_control);
 286
 287                         h_scroll = new ImplicitHScrollBar ();
 288                         Controls.AddImplicit (this.h_scroll);
 289
 290                         v_scroll = new ImplicitVScrollBar ();
 291                         Controls.AddImplicit (this.v_scroll);
 292
 293                         h_marker = v_marker = 0;
 294                         keysearch_tickcnt = 0;
 295
 296                         // scroll bars are disabled initially
 297                         h_scroll.Visible = false;
 298                         h_scroll.ValueChanged += new EventHandler(HorizontalScroller);
 299                         v_scroll.Visible = false;
 300                         v_scroll.ValueChanged += new EventHandler(VerticalScroller);
 301
 302                         // event handlers
 303                         base.KeyDown += new KeyEventHandler(ListView_KeyDown);
 304                         SizeChanged += new EventHandler (ListView_SizeChanged);
 305                         GotFocus += new EventHandler (FocusChanged);
 306                         LostFocus += new EventHandler (FocusChanged);
 307                         MouseWheel += new MouseEventHandler(ListView_MouseWheel);
 308                         MouseEnter += new EventHandler (ListView_MouseEnter);
 309                         Invalidated += new InvalidateEventHandler (ListView_Invalidated);
 310
 311                         BackgroundImageTiled = false;
 312
 313                         this.SetStyle (ControlStyles.UserPaint | ControlStyles.StandardClick
 314                                 | ControlStyles.UseTextForAccessibility
 315                                 , false);
 316                 }
 317                 #endregion      // Public Constructors
 318
 319                 #region Private Internal Properties
 320                 internal Size CheckBoxSize {
 321                         get {
 322                                 if (this.check_boxes) {
 323                                         if (this.state_image_list != null)
 324                                                 return this.state_image_list.ImageSize;
 325                                         else
 326                                                 return ThemeEngine.Current.ListViewCheckBoxSize;
 327                                 }
 328                                 return Size.Empty;
 329                         }
 330                 }
 331
 332                 internal Size ItemSize {
 333                         get {
 334                                 if (view != View.Details)
 335                                         return item_size;
 336
 337                                 Size size = new Size ();
 338                                 size.Height = item_size.Height;
 339                                 for (int i = 0; i < columns.Count; i++)
 340                                         size.Width += columns [i].Wd;
 341
 342                                 return size;
 343                         }
 344                         set {
 345                                 item_size = value;
 346                         }
 347                 }
 348
 349                 internal int HotItemIndex {
 350                         get {
 351                                 return hot_item_index;
 352                         }
 353                         set {
 354                                 hot_item_index = value;
 355                         }
 356                 }
 357
 358                 internal bool UsingGroups {
 359                         get {
 360                                 return show_groups && groups.Count > 0 && view != View.List &&
 361                                         Application.VisualStylesEnabled;
 362                         }
 363                 }
 364
 365                 internal override bool ScaleChildrenInternal {
 366                         get { return false; }
 367                 }
 368
 369                 internal bool UseCustomColumnWidth {
 370                         get {
 371                                 return (view == View.List || view == View.SmallIcon) && columns.Count > 0;
 372                         }
 373                 }
 374
 375                 internal ColumnHeader EnteredColumnHeader {
 376                         get {
 377                                 return header_control.EnteredColumnHeader;
 378                         }
 379                 }
 380                 #endregion      // Private Internal Properties
 381
 382                 #region  Protected Properties
 383                 protected override CreateParams CreateParams {
 384                         get { return base.CreateParams; }
 385                 }
 386
 387                 protected override Size DefaultSize {
 388                         get { return ThemeEngine.Current.ListViewDefaultSize; }
 389                 }
 390                 protected override bool DoubleBuffered {
 391                         get {
 392                                 return base.DoubleBuffered;
 393                         }
 394                         set {
 395                                 base.DoubleBuffered = value;
 396                         }
 397                 }
 398                 #endregion      // Protected Properties
 399
 400                 #region Public Instance Properties
 401                 [DefaultValue (ItemActivation.Standard)]
 402                 public ItemActivation Activation {
 403                         get { return activation; }
 404                         set {
 405                                 if (value != ItemActivation.Standard && value != ItemActivation.OneClick &&
 406                                         value != ItemActivation.TwoClick) {
 407                                         throw new InvalidEnumArgumentException (string.Format
 408                                                 ("Enum argument value '{0}' is not valid for Activation", value));
 409                                 }
 410                                 if (hot_tracking && value != ItemActivation.OneClick)
 411                                         throw new ArgumentException ("When HotTracking is on, activation must be ItemActivation.OneClick");
 412
 413                                 activation = value;
 414                         }
 415                 }
 416
 417                 [DefaultValue (ListViewAlignment.Top)]
 418                 [Localizable (true)]
 419                 public ListViewAlignment Alignment {
 420                         get { return alignment; }
 421                         set {
 422                                 if (value != ListViewAlignment.Default && value != ListViewAlignment.Left &&
 423                                         value != ListViewAlignment.SnapToGrid && value != ListViewAlignment.Top) {
 424                                         throw new InvalidEnumArgumentException (string.Format
 425                                                 ("Enum argument value '{0}' is not valid for Alignment", value));
 426                                 }
 427
 428                                 if (this.alignment != value) {
 429                                         alignment = value;
 430                                         // alignment does not matter in Details/List views
 431                                         if (this.view == View.LargeIcon || this.View == View.SmallIcon)
 432                                                 this.Redraw (true);
 433                                 }
 434                         }
 435                 }
 436
 437                 [DefaultValue (false)]
 438                 public bool AllowColumnReorder {
 439                         get { return allow_column_reorder; }
 440                         set { allow_column_reorder = value; }
 441                 }
 442
 443                 [DefaultValue (true)]
 444                 public bool AutoArrange {
 445                         get { return auto_arrange; }
 446                         set {
 447                                 if (auto_arrange != value) {
 448                                         auto_arrange = value;
 449                                         // autoarrange does not matter in Details/List views
 450                                         if (this.view == View.LargeIcon || this.View == View.SmallIcon)
 451                                                 this.Redraw (true);
 452                                 }
 453                         }
 454                 }
 455
 456                 public override Color BackColor {
 457                         get {
 458                                 if (background_color.IsEmpty)
 459                                         return ThemeEngine.Current.ColorWindow;
 460                                 else
 461                                         return background_color;
 462                         }
 463                         set {
 464                                 background_color = value;
 465                                 item_control.BackColor = value;
 466                         }
 467                 }
 468
 469                 [Browsable (false)]
 470                 [EditorBrowsable (EditorBrowsableState.Never)]
 471                 public override ImageLayout BackgroundImageLayout {
 472                         get {
 473                                 return base.BackgroundImageLayout;
 474                         }
 475                         set {
 476                                 base.BackgroundImageLayout = value;
 477                         }
 478                 }
 479
 480                 [DefaultValue (false)]
 481                 public bool BackgroundImageTiled {
 482                         get {
 483                                 return item_control.BackgroundImageLayout == ImageLayout.Tile;
 484                         }
 485                         set {
 486                                 ImageLayout new_image_layout = value ? ImageLayout.Tile : ImageLayout.None;
 487                                 if (new_image_layout == item_control.BackgroundImageLayout)
 488                                         return;
 489
 490                                 item_control.BackgroundImageLayout = new_image_layout;
 491                         }
 492                 }
 493
 494                 [DefaultValue (BorderStyle.Fixed3D)]
 495                 [DispId (-504)]
 496                 public BorderStyle BorderStyle {
 497                         get { return InternalBorderStyle; }
 498                         set { InternalBorderStyle = value; }
 499                 }
 500
 501                 [DefaultValue (false)]
 502                 public bool CheckBoxes {
 503                         get { return check_boxes; }
 504                         set {
 505                                 if (check_boxes != value) {
 506                                         if (value && View == View.Tile)
 507                                                 throw new NotSupportedException ("CheckBoxes are not"
 508                                                         + " supported in Tile view. Choose a different"
 509                                                         + " view or set CheckBoxes to false.");
 510
 511                                         check_boxes = value;
 512                                         this.Redraw (true);
 513
 514                                         //UIA Framework: Event used by ListView to set/unset Toggle Pattern
 515                                         OnUIACheckBoxesChanged ();
 516                                 }
 517                         }
 518                 }
 519
 520                 [Browsable (false)]
 521                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 522                 public CheckedIndexCollection CheckedIndices {
 523                         get { return checked_indices; }
 524                 }
 525
 526                 [Browsable (false)]
 527                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 528                 public CheckedListViewItemCollection CheckedItems {
 529                         get { return checked_items; }
 530                 }
 531
 532                 [Editor ("System.Windows.Forms.Design.ColumnHeaderCollectionEditor, " + Consts.AssemblySystem_Design, typeof (System.Drawing.Design.UITypeEditor))]
 533                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]
 534                 [Localizable (true)]
 535                 [MergableProperty (false)]
 536                 public ColumnHeaderCollection Columns {
 537                         get { return columns; }
 538                 }
 539
 540                 [Browsable (false)]
 541                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 542                 public ListViewItem FocusedItem {
 543                         get {
 544                                 if (focused_item_index == -1)
 545                                         return null;
 546
 547                                 return GetItemAtDisplayIndex (focused_item_index);
 548                         }
 549                         set {
 550                                 if (value == null || value.ListView != this ||
 551                                                 !IsHandleCreated)
 552                                         return;
 553
 554                                 SetFocusedItem (value.DisplayIndex);
 555                         }
 556                 }
 557
 558                 public override Color ForeColor {
 559                         get {
 560                                 if (foreground_color.IsEmpty)
 561                                         return ThemeEngine.Current.ColorWindowText;
 562                                 else
 563                                         return foreground_color;
 564                         }
 565                         set { foreground_color = value; }
 566                 }
 567
 568                 [DefaultValue (false)]
 569                 public bool FullRowSelect {
 570                         get { return full_row_select; }
 571                         set {
 572                                 if (full_row_select != value) {
 573                                         full_row_select = value;
 574                                         InvalidateSelection ();
 575                                 }
 576                         }
 577                 }
 578
 579                 [DefaultValue (false)]
 580                 public bool GridLines {
 581                         get { return grid_lines; }
 582                         set {
 583                                 if (grid_lines != value) {
 584                                         grid_lines = value;
 585                                         this.Redraw (false);
 586                                 }
 587                         }
 588                 }
 589
 590                 [DefaultValue (ColumnHeaderStyle.Clickable)]
 591                 public ColumnHeaderStyle HeaderStyle {
 592                         get { return header_style; }
 593                         set {
 594                                 if (header_style == value)
 595                                         return;
 596
 597                                 switch (value) {
 598                                 case ColumnHeaderStyle.Clickable:
 599                                 case ColumnHeaderStyle.Nonclickable:
 600                                 case ColumnHeaderStyle.None:
 601                                         break;
 602                                 default:
 603                                         throw new InvalidEnumArgumentException (string.Format
 604                                                 ("Enum argument value '{0}' is not valid for ColumnHeaderStyle", value));
 605                                 }
 606
 607                                 header_style = value;
 608                                 if (view == View.Details)
 609                                         Redraw (true);
 610                         }
 611                 }
 612
 613                 [DefaultValue (true)]
 614                 public bool HideSelection {
 615                         get { return hide_selection; }
 616                         set {
 617                                 if (hide_selection != value) {
 618                                         hide_selection = value;
 619                                         InvalidateSelection ();
 620                                 }
 621                         }
 622                 }
 623
 624                 [DefaultValue (false)]
 625                 public bool HotTracking {
 626                         get {
 627                                 return hot_tracking;
 628                         }
 629                         set {
 630                                 if (hot_tracking == value)
 631                                         return;
 632
 633                                 hot_tracking = value;
 634                                 if (hot_tracking) {
 635                                         hover_selection = true;
 636                                         activation = ItemActivation.OneClick;
 637                                 }
 638                         }
 639                 }
 640
 641                 [DefaultValue (false)]
 642                 public bool HoverSelection {
 643                         get { return hover_selection; }
 644                         set {
 645                                 if (hot_tracking && value == false)
 646                                         throw new ArgumentException ("When HotTracking is on, hover selection must be true");
 647                                 hover_selection = value;
 648                         }
 649                 }
 650
 651                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 652                 [Browsable (false)]
 653                 public ListViewInsertionMark InsertionMark {
 654                         get {
 655                                 return insertion_mark;
 656                         }
 657                 }
 658
 659                 [Editor ("System.Windows.Forms.Design.ListViewItemCollectionEditor, " + Consts.AssemblySystem_Design, typeof (System.Drawing.Design.UITypeEditor))]
 660                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]
 661                 [Localizable (true)]
 662                 [MergableProperty (false)]
 663                 public ListViewItemCollection Items {
 664                         get { return items; }
 665                 }
 666
 667                 [DefaultValue (false)]
 668                 public bool LabelEdit {
 669                         get { return label_edit; }
 670                         set {
 671                                 if (value != label_edit) {
 672                                         label_edit = value;
 673
 674                                         // UIA Framework: Event used by Value Pattern in ListView.ListItem provider
 675                                         OnUIALabelEditChanged ();
 676                                 }
 677
 678                         }
 679                 }
 680
 681                 [DefaultValue (true)]
 682                 [Localizable (true)]
 683                 public bool LabelWrap {
 684                         get { return label_wrap; }
 685                         set {
 686                                 if (label_wrap != value) {
 687                                         label_wrap = value;
 688                                         this.Redraw (true);
 689                                 }
 690                         }
 691                 }
 692
 693                 [DefaultValue (null)]
 694                 public ImageList LargeImageList {
 695                         get { return large_image_list; }
 696                         set {
 697                                 large_image_list = value;
 698                                 this.Redraw (true);
 699                         }
 700                 }
 701
 702                 [Browsable (false)]
 703                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 704                 public IComparer ListViewItemSorter {
 705                         get {
 706                                 if (View != View.SmallIcon && View != View.LargeIcon && item_sorter is ItemComparer)
 707                                         return null;
 708                                 return item_sorter;
 709                         }
 710                         set {
 711                                 if (item_sorter != value) {
 712                                         item_sorter = value;
 713                                         Sort ();
 714                                 }
 715                         }
 716                 }
 717
 718                 [DefaultValue (true)]
 719                 public bool MultiSelect {
 720                         get { return multiselect; }
 721                         set {
 722                                 if (value != multiselect) {
 723                                         multiselect = value;
 724
 725                                         // UIA Framework: Event used by Selection Pattern in ListView.ListItem provider
 726                                         OnUIAMultiSelectChanged ();
 727                                 }
 728                         }
 729                 }
 730
 731
 732                 [DefaultValue(false)]
 733                 public bool OwnerDraw {
 734                         get { return owner_draw; }
 735                         set {
 736                                 owner_draw = value;
 737                                 Redraw (true);
 738                         }
 739                 }
 740
 741                 [Browsable (false)]
 742                 [EditorBrowsable (EditorBrowsableState.Never)]
 743                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 744                 public new Padding Padding {
 745                         get {
 746                                 return base.Padding;
 747                         }
 748                         set {
 749                                 base.Padding = value;
 750                         }
 751                 }
 752
 753                 [MonoTODO ("RTL not supported")]
 754                 [Localizable (true)]
 755                 [DefaultValue (false)]
 756                 public virtual bool RightToLeftLayout {
 757                         get { return right_to_left_layout; }
 758                         set {
 759                                 if (right_to_left_layout != value) {
 760                                         right_to_left_layout = value;
 761                                         OnRightToLeftLayoutChanged (EventArgs.Empty);
 762                                 }
 763                         }
 764                 }
 765
 766                 [DefaultValue (true)]
 767                 public bool Scrollable {
 768                         get { return scrollable; }
 769                         set {
 770                                 if (scrollable != value) {
 771                                         scrollable = value;
 772                                         this.Redraw (true);
 773                                 }
 774                         }
 775                 }
 776
 777                 [Browsable (false)]
 778                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 779                 public SelectedIndexCollection SelectedIndices {
 780                         get { return selected_indices; }
 781                 }
 782
 783                 [Browsable (false)]
 784                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 785                 public SelectedListViewItemCollection SelectedItems {
 786                         get { return selected_items; }
 787                 }
 788
 789                 [DefaultValue(true)]
 790                 public bool ShowGroups {
 791                         get { return show_groups; }
 792                         set {
 793                                 if (show_groups != value) {
 794                                         show_groups = value;
 795                                         Redraw(true);
 796
 797                                         // UIA Framework: Used to update a11y Tree
 798                                         OnUIAShowGroupsChanged ();
 799                                 }
 800                         }
 801                 }
 802
 803                 [LocalizableAttribute (true)]
 804                 [MergableProperty (false)]
 805                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]
 806                 [Editor ("System.Windows.Forms.Design.ListViewGroupCollectionEditor, " + Consts.AssemblySystem_Design, typeof (System.Drawing.Design.UITypeEditor))]
 807                 public ListViewGroupCollection Groups {
 808                         get { return groups; }
 809                 }
 810
 811                 [DefaultValue (false)]
 812                 public bool ShowItemToolTips {
 813                         get {
 814                                 return show_item_tooltips;
 815                         }
 816                         set {
 817                                 show_item_tooltips = value;
 818                                 item_tooltip.Active = false;
 819                         }
 820                 }
 821
 822                 [DefaultValue (null)]
 823                 public ImageList SmallImageList {
 824                         get { return small_image_list; }
 825                         set {
 826                                 small_image_list = value;
 827                                 this.Redraw (true);
 828                         }
 829                 }
 830
 831                 [DefaultValue (SortOrder.None)]
 832                 public SortOrder Sorting {
 833                         get { return sort_order; }
 834                         set {
 835                                 if (!Enum.IsDefined (typeof (SortOrder), value)) {
 836                                         throw new InvalidEnumArgumentException ("value", (int) value,
 837                                                 typeof (SortOrder));
 838                                 }
 839
 840                                 if (sort_order == value)
 841                                         return;
 842
 843                                 sort_order = value;
 844
 845                                 if (virtual_mode) // Sorting is not allowed in virtual mode
 846                                         return;
 847
 848                                 if (value == SortOrder.None) {
 849                                         if (item_sorter != null) {
 850                                                 // ListViewItemSorter should never be reset for SmallIcon
 851                                                 // and LargeIcon view
 852                                                 if (View != View.SmallIcon && View != View.LargeIcon)
 853                                                         item_sorter = null;
 854                                         }
 855                                         this.Redraw (false);
 856                                 } else {
 857                                         if (item_sorter == null)
 858                                                 item_sorter = new ItemComparer (value);
 859                                         if (item_sorter is ItemComparer) {
 860                                                 item_sorter = new ItemComparer (value);
 861                                         }
 862                                         Sort ();
 863                                 }
 864                         }
 865                 }
 866
 867                 private void OnImageListChanged (object sender, EventArgs args)
 868                 {
 869                         item_control.Invalidate ();
 870                 }
 871
 872                 [DefaultValue (null)]
 873                 public ImageList StateImageList {
 874                         get { return state_image_list; }
 875                         set {
 876                                 if (state_image_list == value)
 877                                         return;
 878
 879                                 if (state_image_list != null)
 880                                         state_image_list.Images.Changed -= new EventHandler (OnImageListChanged);
 881
 882                                 state_image_list = value;
 883
 884                                 if (state_image_list != null)
 885                                         state_image_list.Images.Changed += new EventHandler (OnImageListChanged);
 886
 887                                 this.Redraw (true);
 888                         }
 889                 }
 890
 891                 [Bindable (false)]
 892                 [Browsable (false)]
 893                 [EditorBrowsable (EditorBrowsableState.Never)]
 894                 public override string Text {
 895                         get { return base.Text; }
 896                         set {
 897                                 if (value == base.Text)
 898                                         return;
 899
 900                                 base.Text = value;
 901                                 this.Redraw (true);
 902                         }
 903                 }
 904
 905                 [Browsable (true)]
 906                 public Size TileSize {
 907                         get {
 908                                 return tile_size;
 909                         }
 910                         set {
 911                                 if (value.Width <= 0 || value.Height <= 0)
 912                                         throw new ArgumentOutOfRangeException ("value");
 913
 914                                 tile_size = value;
 915                                 if (view == View.Tile)
 916                                         Redraw (true);
 917                         }
 918                 }
 919
 920                 [Browsable (false)]
 921                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 922                 public ListViewItem TopItem {
 923                         get {
 924                                 if (view == View.LargeIcon || view == View.SmallIcon || view == View.Tile)
 925                                         throw new InvalidOperationException ("Cannot get the top item in LargeIcon, SmallIcon or Tile view.");
 926                                 // there is no item
 927                                 if (this.items.Count == 0)
 928                                         return null;
 929                                 // if contents are not scrolled
 930                                 // it is the first item
 931                                 else if (h_marker == 0 && v_marker == 0)
 932                                         return this.items [0];
 933                                 // do a hit test for the scrolled position
 934                                 else {
 935                                         int header_offset = header_control.Height;
 936                                         for (int i = 0; i < items.Count; i++) {
 937                                                 Point item_loc = GetItemLocation (i);
 938                                                 if (item_loc.X >= 0 && item_loc.Y - header_offset >= 0)
 939                                                         return items [i];
 940                                         }
 941                                         return null;
 942                                 }
 943                         }
 944                         set {
 945                                 if (view == View.LargeIcon || view == View.SmallIcon || view == View.Tile)
 946                                         throw new InvalidOperationException ("Cannot set the top item in LargeIcon, SmallIcon or Tile view.");
 947
 948                                 // .Net doesn't throw any exception in the cases below
 949                                 if (value == null || value.ListView != this)
 950                                         return;
 951
 952                                 // Take advantage this property is only valid for Details view.
 953                                 SetScrollValue (v_scroll, item_size.Height * value.Index);
 954                         }
 955                 }
 956
 957                 [EditorBrowsable (EditorBrowsableState.Advanced)]
 958                 [DefaultValue (true)]
 959                 [Browsable (false)]
 960                 [MonoInternalNote ("Stub, not implemented")]
 961                 public bool UseCompatibleStateImageBehavior {
 962                         get {
 963                                 return false;
 964                         }
 965                         set {
 966                         }
 967                 }
 968
 969                 [DefaultValue (View.LargeIcon)]
 970                 public View View {
 971                         get { return view; }
 972                         set {
 973                                 if (!Enum.IsDefined (typeof (View), value))
 974                                         throw new InvalidEnumArgumentException ("value", (int) value,
 975                                                 typeof (View));
 976
 977                                 if (view != value) {
 978                                         if (CheckBoxes && value == View.Tile)
 979                                                 throw new NotSupportedException ("CheckBoxes are not"
 980                                                         + " supported in Tile view. Choose a different"
 981                                                         + " view or set CheckBoxes to false.");
 982                                         if (VirtualMode && value == View.Tile)
 983                                                 throw new NotSupportedException ("VirtualMode is"
 984                                                         + " not supported in Tile view. Choose a different"
 985                                                         + " view or set ViewMode to false.");
 986
 987                                         h_scroll.Value = v_scroll.Value = 0;
 988                                         view = value;
 989                                         Redraw (true);
 990
 991                                         // UIA Framework: Event used to update UIA Tree.
 992                                         OnUIAViewChanged ();
 993                                 }
 994                         }
 995                 }
 996
 997                 [DefaultValue (false)]
 998                 [RefreshProperties (RefreshProperties.Repaint)]
 999                 public bool VirtualMode {
1000                         get {
1001                                 return virtual_mode;
1002                         }
1003                         set {
1004                                 if (virtual_mode == value)
1005                                         return;
1006
1007                                 if (!virtual_mode && items.Count > 0)
1008                                         throw new InvalidOperationException ();
1009                                 if (value && view == View.Tile)
1010                                         throw new NotSupportedException ("VirtualMode is"
1011                                                 + " not supported in Tile view. Choose a different"
1012                                                 + " view or set ViewMode to false.");
1013
1014                                 virtual_mode = value;
1015                                 Redraw (true);
1016                         }
1017                 }
1018
1019                 [DefaultValue (0)]
1020                 [RefreshProperties (RefreshProperties.Repaint)]
1021                 public int VirtualListSize {
1022                         get {
1023                                 return virtual_list_size;
1024                         }
1025                         set {
1026                                 if (value < 0)
1027                                         throw new ArgumentException ("value");
1028
1029                                 if (virtual_list_size == value)
1030                                         return;
1031
1032                                 virtual_list_size = value;
1033                                 if (virtual_mode) {
1034                                         focused_item_index = -1;
1035                                         selected_indices.Reset ();
1036                                         Redraw (true);
1037                                 }
1038                         }
1039                 }
1040                 #endregion      // Public Instance Properties
1041
1042                 #region Internal Methods Properties
1043
1044                 internal int FirstVisibleIndex {
1045                         get {
1046                                 // there is no item
1047                                 if (this.items.Count == 0)
1048                                         return 0;
1049
1050                                 if (h_marker == 0 && v_marker == 0)
1051                                         return 0;
1052
1053                                 Size item_size = ItemSize;
1054                                 // In virtual mode we always have fixed positions, and we can infer the positon easily
1055                                 if (virtual_mode) {
1056                                         int first = 0;
1057                                         switch (view) {
1058                                                 case View.Details:
1059                                                         first = v_marker / item_size.Height;
1060                                                         break;
1061                                                 case View.LargeIcon:
1062                                                 case View.SmallIcon:
1063                                                         first = (v_marker / (item_size.Height + y_spacing)) * cols;
1064                                                         break;
1065                                                 case View.List:
1066                                                         first = (h_marker / (item_size.Width * x_spacing)) * rows;
1067                                                         break;
1068                                         }
1069
1070                                         if (first >= items.Count)
1071                                                 first = items.Count;
1072
1073                                         return first;
1074                                 }
1075                                 for (int i = 0; i < items.Count; i++) {
1076                                         Rectangle item_rect = new Rectangle (GetItemLocation (i), item_size);
1077                                         if (item_rect.Right >= 0 && item_rect.Bottom >= 0)
1078                                                 return i;
1079                                 }
1080
1081                                 return 0;
1082                         }
1083                 }
1084
1085
1086                 internal int LastVisibleIndex {
1087                         get {
1088                                 for (int i = FirstVisibleIndex; i < Items.Count; i++) {
1089                                         if (View == View.List || Alignment == ListViewAlignment.Left) {
1090                                                 if (GetItemLocation (i).X > item_control.ClientRectangle.Right)
1091                                                         return i - 1;
1092                                         } else {
1093                                                 if (GetItemLocation (i).Y > item_control.ClientRectangle.Bottom)
1094                                                         return i - 1;
1095                                         }
1096                                 }
1097
1098                                 return Items.Count - 1;
1099                         }
1100                 }
1101
1102                 internal void OnSelectedIndexChanged ()
1103                 {
1104                         if (is_selection_available)
1105                                 OnSelectedIndexChanged (EventArgs.Empty);
1106                 }
1107
1108                 internal int TotalWidth {
1109                         get { return Math.Max (this.Width, this.layout_wd); }
1110                 }
1111
1112                 internal int TotalHeight {
1113                         get { return Math.Max (this.Height, this.layout_ht); }
1114                 }
1115
1116                 internal void Redraw (bool recalculate)
1117                 {
1118                         // Avoid calculations when control is being updated
1119                         if (updating)
1120                                 return;
1121                         // VirtualMode doesn't do any calculations until handle is created
1122                         if (virtual_mode && !IsHandleCreated)
1123                                 return;
1124
1125
1126                         if (recalculate)
1127                                 CalculateListView (this.alignment);
1128
1129                         Invalidate (true);
1130                 }
1131
1132                 void InvalidateSelection ()
1133                 {
1134                         foreach (int selected_index in SelectedIndices)
1135                                 items [selected_index].Invalidate ();
1136                 }
1137
1138                 const int text_padding = 15;
1139
1140                 internal Size GetChildColumnSize (int index)
1141                 {
1142                         Size ret_size = Size.Empty;
1143                         ColumnHeader col = this.columns [index];
1144
1145                         if (col.Width == -2) { // autosize = max(items, columnheader)
1146                                 Size size = Size.Ceiling (TextRenderer.MeasureString
1147                                         (col.Text, this.Font));
1148                                 size.Width += text_padding;
1149                                 ret_size = BiggestItem (index);
1150                                 if (size.Width > ret_size.Width)
1151                                         ret_size = size;
1152                         }
1153                         else { // -1 and all the values < -2 are put under one category
1154                                 ret_size = BiggestItem (index);
1155                                 // fall back to empty columns' width if no subitem is available for a column
1156                                 if (ret_size.IsEmpty) {
1157                                         ret_size.Width = ThemeEngine.Current.ListViewEmptyColumnWidth;
1158                                         if (col.Text.Length > 0)
1159                                                 ret_size.Height = Size.Ceiling (TextRenderer.MeasureString
1160                                                                                 (col.Text, this.Font)).Height;
1161                                         else
1162                                                 ret_size.Height = this.Font.Height;
1163                                 }
1164                         }
1165
1166                         ret_size.Height += text_padding;
1167
1168                         // adjust the size for icon and checkbox for 0th column
1169                         if (index == 0) {
1170                                 ret_size.Width += (this.CheckBoxSize.Width + 4);
1171                                 if (this.small_image_list != null)
1172                                         ret_size.Width += this.small_image_list.ImageSize.Width;
1173                         }
1174                         return ret_size;
1175                 }
1176
1177                 // Returns the size of biggest item text in a column
1178                 // or the sum of the text and indent count if we are on 2.0
1179                 private Size BiggestItem (int col)
1180                 {
1181                         Size temp = Size.Empty;
1182                         Size ret_size = Size.Empty;
1183                         bool use_indent_count = small_image_list != null;
1184
1185                         // VirtualMode uses the first item text size
1186                         if (virtual_mode && items.Count > 0) {
1187                                 ListViewItem item = items [0];
1188                                 ret_size = Size.Ceiling (TextRenderer.MeasureString (item.SubItems[col].Text,
1189                                                         Font));
1190
1191                                 if (use_indent_count)
1192                                         ret_size.Width += item.IndentCount * small_image_list.ImageSize.Width;
1193                         } else {
1194                                 // 0th column holds the item text, we check the size of
1195                                 // the various subitems falling in that column and get
1196                                 // the biggest one's size.
1197                                 foreach (ListViewItem item in items) {
1198                                         if (col >= item.SubItems.Count)
1199                                                 continue;
1200
1201                                         temp = Size.Ceiling (TextRenderer.MeasureString
1202                                                                 (item.SubItems [col].Text, Font));
1203
1204                                         if (use_indent_count)
1205                                                 temp.Width += item.IndentCount * small_image_list.ImageSize.Width;
1206
1207                                         if (temp.Width > ret_size.Width)
1208                                                 ret_size = temp;
1209                                 }
1210                         }
1211
1212                         // adjustment for space in Details view
1213                         if (!ret_size.IsEmpty && view == View.Details)
1214                                 ret_size.Width += ThemeEngine.Current.ListViewItemPaddingWidth;
1215
1216                         return ret_size;
1217                 }
1218
1219                 const int max_wrap_padding = 30;
1220
1221                 // Sets the size of the biggest item text as per the view
1222                 private void CalcTextSize ()
1223                 {
1224                         // clear the old value
1225                         text_size = Size.Empty;
1226
1227                         if (items.Count == 0)
1228                                 return;
1229
1230                         text_size = BiggestItem (0);
1231
1232                         if (view == View.LargeIcon && this.label_wrap) {
1233                                 Size temp = Size.Empty;
1234                                 if (this.check_boxes)
1235                                         temp.Width += 2 * this.CheckBoxSize.Width;
1236                                 int icon_w = LargeImageList == null ? 12 : LargeImageList.ImageSize.Width;
1237                                 temp.Width += icon_w + max_wrap_padding;
1238                                 // wrapping is done for two lines only
1239                                 if (text_size.Width > temp.Width) {
1240                                         text_size.Width = temp.Width;
1241                                         text_size.Height *= 2;
1242                                 }
1243                         }
1244                         else if (view == View.List) {
1245                                 // in list view max text shown in determined by the
1246                                 // control width, even if scolling is enabled.
1247                                 int max_wd = this.Width - (this.CheckBoxSize.Width - 2);
1248                                 if (this.small_image_list != null)
1249                                         max_wd -= this.small_image_list.ImageSize.Width;
1250
1251                                 if (text_size.Width > max_wd)
1252                                         text_size.Width = max_wd;
1253                         }
1254
1255                         // we do the default settings, if we have got 0's
1256                         if (text_size.Height <= 0)
1257                                 text_size.Height = this.Font.Height;
1258                         if (text_size.Width <= 0)
1259                                 text_size.Width = this.Width;
1260
1261                         // little adjustment
1262                         text_size.Width += 2;
1263                         text_size.Height += 2;
1264                 }
1265
1266                 private void SetScrollValue (ScrollBar scrollbar, int val)
1267                 {
1268                         int max;
1269                         if (scrollbar == h_scroll)
1270                                 max = h_scroll.Maximum - h_scroll.LargeChange + 1;
1271                         else
1272                                 max = v_scroll.Maximum - v_scroll.LargeChange + 1;
1273
1274                         if (val > max)
1275                                 val = max;
1276                         else if (val < scrollbar.Minimum)
1277                                 val = scrollbar.Minimum;
1278
1279                         scrollbar.Value = val;
1280                 }
1281
1282                 private void Scroll (ScrollBar scrollbar, int delta)
1283                 {
1284                         if (delta == 0 || !scrollbar.Visible)
1285                                 return;
1286
1287                         SetScrollValue (scrollbar, scrollbar.Value + delta);
1288                 }
1289
1290                 private void CalculateScrollBars ()
1291                 {
1292                         Rectangle client_area = ClientRectangle;
1293                         int height = client_area.Height;
1294                         int width = client_area.Width;
1295                         Size item_size;
1296
1297                         if (!scrollable) {
1298                                 h_scroll.Visible = false;
1299                                 v_scroll.Visible = false;
1300                                 item_control.Size = new Size (width, height);
1301                                 header_control.Width = width;
1302                                 return;
1303                         }
1304
1305                         // Don't calculate if the view is not displayable
1306                         if (client_area.Height < 0 || client_area.Width < 0)
1307                                 return;
1308
1309                         // making a scroll bar visible might make
1310                         // other scroll bar visible
1311                         if (layout_wd > client_area.Right) {
1312                                 h_scroll.Visible = true;
1313                                 if ((layout_ht + h_scroll.Height) > client_area.Bottom)
1314                                         v_scroll.Visible = true;
1315                                 else
1316                                         v_scroll.Visible = false;
1317                         } else if (layout_ht > client_area.Bottom) {
1318                                 v_scroll.Visible = true;
1319                                 if ((layout_wd + v_scroll.Width) > client_area.Right)
1320                                         h_scroll.Visible = true;
1321                                 else
1322                                         h_scroll.Visible = false;
1323                         } else {
1324                                 h_scroll.Visible = false;
1325                                 v_scroll.Visible = false;
1326                         }
1327
1328
1329                         item_size = ItemSize;
1330
1331                         if (h_scroll.is_visible) {
1332                                 h_scroll.Location = new Point (client_area.X, client_area.Bottom - h_scroll.Height);
1333                                 h_scroll.Minimum = 0;
1334
1335                                 // if v_scroll is visible, adjust the maximum of the
1336                                 // h_scroll to account for the width of v_scroll
1337                                 if (v_scroll.Visible) {
1338                                         h_scroll.Maximum = layout_wd + v_scroll.Width;
1339                                         h_scroll.Width = client_area.Width - v_scroll.Width;
1340                                 }
1341                                 else {
1342                                         h_scroll.Maximum = layout_wd;
1343                                         h_scroll.Width = client_area.Width;
1344                                 }
1345
1346                                 if (view == View.List)
1347                                         h_scroll.SmallChange = item_size.Width + ThemeEngine.Current.ListViewHorizontalSpacing;
1348                                 else
1349                                         h_scroll.SmallChange = Font.Height;
1350
1351                                 h_scroll.LargeChange = client_area.Width;
1352                                 height -= h_scroll.Height;
1353                         }
1354
1355                         if (v_scroll.is_visible) {
1356                                 v_scroll.Location = new Point (client_area.Right - v_scroll.Width, client_area.Y);
1357                                 v_scroll.Minimum = 0;
1358
1359                                 // if h_scroll is visible, adjust the height of
1360                                 // v_scroll to account for the height of h_scroll
1361                                 if (h_scroll.Visible) {
1362                                         v_scroll.Maximum = layout_ht + h_scroll.Height;
1363                                         v_scroll.Height = client_area.Height > h_scroll.Height ? client_area.Height - h_scroll.Height : 0;
1364                                 } else {
1365                                         v_scroll.Maximum = layout_ht;
1366                                         v_scroll.Height = client_area.Height;
1367                                 }
1368
1369                                 if (view == View.Details) {
1370                                         // Need to update Maximum if using LargeChange with value other than the visible area
1371                                         int headerPlusOneItem = header_control.Height + item_size.Height;
1372                                         v_scroll.LargeChange = v_scroll.Height > headerPlusOneItem ? v_scroll.Height - headerPlusOneItem : 0;
1373                                         v_scroll.Maximum = v_scroll.Maximum > headerPlusOneItem ? v_scroll.Maximum - headerPlusOneItem : 0;
1374                                 } else
1375                                         v_scroll.LargeChange = v_scroll.Height;
1376
1377                                 v_scroll.SmallChange = item_size.Height;
1378                                 width -= v_scroll.Width;
1379                         }
1380
1381                         item_control.Size = new Size (width, height);
1382
1383                         if (header_control.is_visible)
1384                                 header_control.Width = width;
1385                 }
1386
1387                 internal int GetReorderedColumnIndex (ColumnHeader column)
1388                 {
1389                         if (reordered_column_indices == null)
1390                                 return column.Index;
1391
1392                         for (int i = 0; i < Columns.Count; i++)
1393                                 if (reordered_column_indices [i] == column.Index)
1394                                         return i;
1395
1396                         return -1;
1397                 }
1398
1399                 internal ColumnHeader GetReorderedColumn (int index)
1400                 {
1401                         if (reordered_column_indices == null)
1402                                 return Columns [index];
1403                         else
1404                                 return Columns [reordered_column_indices [index]];
1405                 }
1406
1407                 internal void ReorderColumn (ColumnHeader col, int index, bool fireEvent)
1408                 {
1409                         if (fireEvent) {
1410                                 ColumnReorderedEventHandler eh = (ColumnReorderedEventHandler) (Events [ColumnReorderedEvent]);
1411                                 if (eh != null){
1412                                         ColumnReorderedEventArgs args = new ColumnReorderedEventArgs (col.Index, index, col);
1413
1414                                         eh (this, args);
1415                                         if (args.Cancel) {
1416                                                 header_control.Invalidate ();
1417                                                 item_control.Invalidate ();
1418                                                 return;
1419                                         }
1420                                 }
1421                         }
1422                         int column_count = Columns.Count;
1423
1424                         if (reordered_column_indices == null) {
1425                                 reordered_column_indices = new int [column_count];
1426                                 for (int i = 0; i < column_count; i++)
1427                                         reordered_column_indices [i] = i;
1428                         }
1429
1430                         if (reordered_column_indices [index] == col.Index)
1431                                 return;
1432
1433                         int[] curr = reordered_column_indices;
1434                         int [] result = new int [column_count];
1435                         int curr_idx = 0;
1436                         for (int i = 0; i < column_count; i++) {
1437                                 if (curr_idx < column_count && curr [curr_idx] == col.Index)
1438                                         curr_idx++;
1439
1440                                 if (i == index)
1441                                         result [i] = col.Index;
1442                                 else
1443                                         result [i] = curr [curr_idx++];
1444                         }
1445
1446                         ReorderColumns (result, true);
1447                 }
1448
1449                 internal void ReorderColumns (int [] display_indices, bool redraw)
1450                 {
1451                         reordered_column_indices = display_indices;
1452                         for (int i = 0; i < Columns.Count; i++) {
1453                                 ColumnHeader col = Columns [i];
1454                                 col.InternalDisplayIndex = reordered_column_indices [i];
1455                         }
1456                         if (redraw && view == View.Details && IsHandleCreated) {
1457                                 LayoutDetails ();
1458                                 header_control.Invalidate ();
1459                                 item_control.Invalidate ();
1460                         }
1461                 }
1462
1463                 internal void AddColumn (ColumnHeader newCol, int index, bool redraw)
1464                 {
1465                         int column_count = Columns.Count;
1466                         newCol.SetListView (this);
1467
1468                         int [] display_indices = new int [column_count];
1469                         for (int i = 0; i < column_count; i++) {
1470                                 ColumnHeader col = Columns [i];
1471                                 if (i == index) {
1472                                         display_indices [i] = index;
1473                                 } else {
1474                                         int display_index = col.InternalDisplayIndex;
1475                                         if (display_index < index) {
1476                                                 display_indices [i] = display_index;
1477                                         } else {
1478                                                 display_indices [i] = (display_index + 1);
1479                                         }
1480                                 }
1481                         }
1482
1483                         ReorderColumns (display_indices, redraw);
1484                         Invalidate ();
1485                 }
1486
1487                 Size LargeIconItemSize
1488                 {
1489                         get {
1490                                 int image_w = LargeImageList == null ? 12 : LargeImageList.ImageSize.Width;
1491                                 int image_h = LargeImageList == null ? 2 : LargeImageList.ImageSize.Height;
1492                                 int h = text_size.Height + 2 + Math.Max (CheckBoxSize.Height, image_h);
1493                                 int w = Math.Max (text_size.Width, image_w);
1494
1495                                 if (check_boxes)
1496                                         w += 2 + CheckBoxSize.Width;
1497
1498                                 return new Size (w, h);
1499                         }
1500                 }
1501
1502                 Size SmallIconItemSize {
1503                         get {
1504                                 int image_w = SmallImageList == null ? 0 : SmallImageList.ImageSize.Width;
1505                                 int image_h = SmallImageList == null ? 0 : SmallImageList.ImageSize.Height;
1506                                 int h = Math.Max (text_size.Height, Math.Max (CheckBoxSize.Height, image_h));
1507                                 int w = text_size.Width + image_w;
1508
1509                                 if (check_boxes)
1510                                         w += 2 + CheckBoxSize.Width;
1511
1512                                 return new Size (w, h);
1513                         }
1514                 }
1515
1516                 Size TileItemSize {
1517                         get {
1518                                 // Calculate tile size if needed
1519                                 // It appears that using Font.Size instead of a SizeF value can give us
1520                                 // a slightly better approach to the proportions defined in .Net
1521                                 if (tile_size == Size.Empty) {
1522                                         int image_w = LargeImageList == null ? 0 : LargeImageList.ImageSize.Width;
1523                                         int image_h = LargeImageList == null ? 0 : LargeImageList.ImageSize.Height;
1524                                         int w = (int)Font.Size * ThemeEngine.Current.ListViewTileWidthFactor + image_w + 4;
1525                                         int h = Math.Max ((int)Font.Size * ThemeEngine.Current.ListViewTileHeightFactor, image_h);
1526
1527                                         tile_size = new Size (w, h);
1528                                 }
1529
1530                                 return tile_size;
1531                         }
1532                 }
1533
1534                 int GetDetailsItemHeight ()
1535                 {
1536                         int item_height;
1537                         int checkbox_height = CheckBoxes ? CheckBoxSize.Height : 0;
1538                         int small_image_height = SmallImageList == null ? 0 : SmallImageList.ImageSize.Height;
1539                         item_height = Math.Max (checkbox_height, text_size.Height);
1540                         item_height = Math.Max (item_height, small_image_height);
1541                         return item_height;
1542                 }
1543
1544                 void SetItemLocation (int index, int x, int y, int row, int col)
1545                 {
1546                         Point old_location = items_location [index];
1547                         if (old_location.X == x && old_location.Y == y)
1548                                 return;
1549
1550                         items_location [index] = new Point (x, y);
1551                         items_matrix_location [index] = new ItemMatrixLocation (row, col);
1552
1553                         //
1554                         // Initial position matches item's position in ListViewItemCollection
1555                         //
1556                         reordered_items_indices [index] = index;
1557                 }
1558
1559
1560                 void ShiftItemsPositions (int from, int to, bool forward)
1561                 {
1562                         if (forward) {
1563                                 for (int i = to + 1; i > from; i--) {
1564                                         reordered_items_indices [i] = reordered_items_indices [i - 1];
1565
1566                                         ListViewItem item = items [reordered_items_indices [i]];
1567                                         item.Invalidate ();
1568                                         item.DisplayIndex = i;
1569                                         item.Invalidate ();
1570                                 }
1571                         } else {
1572                                 for (int i = from - 1; i < to; i++) {
1573                                         reordered_items_indices [i] = reordered_items_indices [i + 1];
1574
1575                                         ListViewItem item = items [reordered_items_indices [i]];
1576                                         item.Invalidate ();
1577                                         item.DisplayIndex = i;
1578                                         item.Invalidate ();
1579                                 }
1580                         }
1581                 }
1582
1583                 internal void ChangeItemLocation (int display_index, Point new_pos)
1584                 {
1585                         int new_display_index = GetDisplayIndexFromLocation (new_pos);
1586                         if (new_display_index == display_index)
1587                                 return;
1588
1589                         int item_index = reordered_items_indices [display_index];
1590                         ListViewItem item = items [item_index];
1591
1592                         bool forward = new_display_index < display_index;
1593                         int index_from, index_to;
1594                         if (forward) {
1595                                 index_from = new_display_index;
1596                                 index_to = display_index - 1;
1597                         } else {
1598                                 index_from = display_index + 1;
1599                                 index_to = new_display_index;
1600                         }
1601
1602                         ShiftItemsPositions (index_from, index_to, forward);
1603
1604                         reordered_items_indices [new_display_index] = item_index;
1605
1606                         item.Invalidate ();
1607                         item.DisplayIndex = new_display_index;
1608                         item.Invalidate ();
1609                 }
1610
1611                 int GetDisplayIndexFromLocation (Point loc)
1612                 {
1613                         int display_index = -1;
1614                         Rectangle item_area;
1615
1616                         // First item
1617                         if (loc.X < 0 || loc.Y < 0)
1618                                 return 0;
1619
1620                         // Adjustment to put in the next position refered by 'loc'
1621                         loc.X -= item_size.Width / 2;
1622                         if (loc.X < 0)
1623                                 loc.X = 0;
1624
1625                         for (int i = 0; i < items.Count; i++) {
1626                                 item_area = new Rectangle (GetItemLocation (i), item_size);
1627                                 item_area.Inflate (ThemeEngine.Current.ListViewHorizontalSpacing,
1628                                                 ThemeEngine.Current.ListViewVerticalSpacing);
1629
1630                                 if (item_area.Contains (loc)) {
1631                                         display_index = i;
1632                                         break;
1633                                 }
1634                         }
1635
1636                         // Put in in last position
1637                         if (display_index == -1)
1638                                 display_index = items.Count - 1;
1639
1640                         return display_index;
1641                 }
1642
1643                 // When using groups, the items with no group assigned
1644                 // belong to the DefaultGroup
1645                 int GetDefaultGroupItems ()
1646                 {
1647                         int count = 0;
1648                         foreach (ListViewItem item in items)
1649                                 if (item.Group == null)
1650                                         count++;
1651
1652                         return count;
1653                 }
1654
1655                 // cache the spacing to let virtualmode compute the positions on the fly
1656                 int x_spacing;
1657                 int y_spacing;
1658                 int rows;
1659                 int cols;
1660                 int[,] item_index_matrix;
1661
1662                 void CalculateRowsAndCols (Size item_size, bool left_aligned, int x_spacing, int y_spacing)
1663                 {
1664                         Rectangle area = ClientRectangle;
1665
1666                         if (UseCustomColumnWidth)
1667                                 CalculateCustomColumnWidth ();
1668                         if (UsingGroups) {
1669                                 // When groups are used the alignment is always top-aligned
1670                                 rows = 0;
1671                                 cols = 0;
1672                                 int items = 0;
1673
1674                                 groups.DefaultGroup.ItemCount = GetDefaultGroupItems ();
1675                                 for (int i = 0; i < groups.InternalCount; i++) {
1676                                         ListViewGroup group = groups.GetInternalGroup (i);
1677                                         int items_in_group = group.GetActualItemCount ();
1678
1679                                         if (items_in_group == 0)
1680                                                 continue;
1681
1682                                         int group_cols = (int) Math.Floor ((double)(area.Width - v_scroll.Width + x_spacing) / (double)(item_size.Width + x_spacing));
1683                                         if (group_cols <= 0)
1684                                                 group_cols = 1;
1685                                         int group_rows = (int) Math.Ceiling ((double)items_in_group / (double)group_cols);
1686
1687                                         group.starting_row = rows;
1688                                         group.rows = group_rows;
1689                                         group.starting_item = items;
1690                                         group.current_item = 0; // Reset layout
1691
1692                                         cols = Math.Max (group_cols, cols);
1693                                         rows += group_rows;
1694                                         items += items_in_group;
1695                                 }
1696                         } else
1697                         {
1698                                 // Simple matrix if no groups are used
1699                                 if (left_aligned) {
1700                                         rows = (int) Math.Floor ((double)(area.Height - h_scroll.Height + y_spacing) / (double)(item_size.Height + y_spacing));
1701                                         if (rows <= 0)
1702                                                 rows = 1;
1703                                         cols = (int) Math.Ceiling ((double)items.Count / (double)rows);
1704                                 } else {
1705                                         if (UseCustomColumnWidth)
1706                                                 cols = (int) Math.Floor ((double)(area.Width - v_scroll.Width) / (double)(custom_column_width));
1707                                         else
1708                                                 cols = (int) Math.Floor ((double)(area.Width - v_scroll.Width + x_spacing) / (double)(item_size.Width + x_spacing));
1709
1710                                         if (cols < 1)
1711                                                 cols = 1;
1712
1713                                         rows = (int) Math.Ceiling ((double)items.Count / (double)cols);
1714                                 }
1715                         }
1716
1717                         item_index_matrix = new int [rows, cols];
1718                 }
1719
1720                 // When using custom column width, we look for the minimum one
1721                 void CalculateCustomColumnWidth ()
1722                 {
1723                         int min_width = Int32.MaxValue;
1724                         for (int i = 0; i < columns.Count; i++) {
1725                                 int col_width = columns [i].Width;
1726
1727                                 if (col_width < min_width)
1728                                         min_width = col_width;
1729                         }
1730
1731                         custom_column_width = min_width;
1732                 }
1733
1734                 void LayoutIcons (Size item_size, bool left_aligned, int x_spacing, int y_spacing)
1735                 {
1736                         header_control.Visible = false;
1737                         header_control.Size = Size.Empty;
1738                         item_control.Visible = true;
1739                         item_control.Location = Point.Empty;
1740                         ItemSize = item_size; // Cache item size
1741                         this.x_spacing = x_spacing;
1742                         this.y_spacing = y_spacing;
1743
1744                         if (items.Count == 0)
1745                                 return;
1746
1747                         Size sz = item_size;
1748
1749                         CalculateRowsAndCols (sz, left_aligned, x_spacing, y_spacing);
1750
1751                         layout_wd = UseCustomColumnWidth ? cols * custom_column_width : cols * (sz.Width + x_spacing) - x_spacing;
1752                         layout_ht = rows * (sz.Height + y_spacing) - y_spacing;
1753
1754                         if (virtual_mode) { // no actual assignment is needed on items for virtual mode
1755                                 item_control.Size = new Size (layout_wd, layout_ht);
1756                                 return;
1757                         }
1758
1759                         bool using_groups = UsingGroups;
1760                         if (using_groups) // the groups layout will override layout_ht
1761                                 CalculateGroupsLayout (sz, y_spacing, 0);
1762
1763                         int row = 0, col = 0;
1764                         int x = 0, y = 0;
1765                         int display_index = 0;
1766
1767                         for (int i = 0; i < items.Count; i++) {
1768                                 ListViewItem item = items [i];
1769                                 if (using_groups) {
1770                                         ListViewGroup group = item.Group;
1771                                         if (group == null)
1772                                                 group = groups.DefaultGroup;
1773
1774                                         Point group_items_loc = group.items_area_location;
1775                                         int current_item = group.current_item++;
1776                                         int starting_row = group.starting_row;
1777
1778                                         display_index = group.starting_item + current_item;
1779                                         row = (current_item / cols);
1780                                         col = current_item % cols;
1781
1782                                         x = UseCustomColumnWidth ? col * custom_column_width : col * (item_size.Width + x_spacing);
1783                                         y = row * (item_size.Height + y_spacing) + group_items_loc.Y;
1784
1785                                         SetItemLocation (display_index, x, y, row + starting_row, col);
1786                                         SetItemAtDisplayIndex (display_index, i);
1787                                         item_index_matrix [row + starting_row, col] = i;
1788
1789                                 } else
1790                                 {
1791                                         x = UseCustomColumnWidth ? col * custom_column_width : col * (item_size.Width + x_spacing);
1792                                         y = row * (item_size.Height + y_spacing);
1793                                         display_index = i; // Same as item index in Items
1794
1795                                         SetItemLocation (i, x, y, row, col);
1796                                         item_index_matrix [row, col] = i;
1797
1798                                         if (left_aligned) {
1799                                                 row++;
1800                                                 if (row == rows) {
1801                                                         row = 0;
1802                                                         col++;
1803                                                 }
1804                                         } else {
1805                                                 if (++col == cols) {
1806                                                         col = 0;
1807                                                         row++;
1808                                                 }
1809                                         }
1810                                 }
1811
1812                                 item.Layout ();
1813                                 item.DisplayIndex = display_index;
1814                                 item.SetPosition (new Point (x, y));
1815                         }
1816
1817                         item_control.Size = new Size (layout_wd, layout_ht);
1818                 }
1819
1820                 void CalculateGroupsLayout (Size item_size, int y_spacing, int y_origin)
1821                 {
1822                         int y = y_origin;
1823                         bool details = view == View.Details;
1824
1825                         for (int i = 0; i < groups.InternalCount; i++) {
1826                                 ListViewGroup group = groups.GetInternalGroup (i);
1827                                 if (group.ItemCount == 0)
1828                                         continue;
1829
1830                                 y += LayoutGroupHeader (group, y, item_size.Height, y_spacing, details ? group.ItemCount : group.rows);
1831                         }
1832
1833                         layout_ht = y; // Update height taking into account Groups' headers heights
1834                 }
1835
1836                 int LayoutGroupHeader (ListViewGroup group, int y_origin, int item_height, int y_spacing, int rows)
1837                 {
1838                         Rectangle client_area = ClientRectangle;
1839                         int header_height = Font.Height + 15; // one line height + some padding
1840
1841                         group.HeaderBounds = new Rectangle (0, y_origin, client_area.Width - v_scroll.Width, header_height);
1842                         group.items_area_location = new Point (0, y_origin + header_height);
1843
1844                         int items_area_height = ((item_height + y_spacing) * rows);
1845                         return header_height + items_area_height + 10; // Add a small bottom margin
1846                 }
1847
1848                 void CalculateDetailsGroupItemsCount ()
1849                 {
1850                         int items = 0;
1851
1852                         groups.DefaultGroup.ItemCount = GetDefaultGroupItems ();
1853                         for (int i = 0; i < groups.InternalCount; i++) {
1854                                 ListViewGroup group = groups.GetInternalGroup (i);
1855                                 int items_in_group = group.GetActualItemCount ();
1856
1857                                 if (items_in_group == 0)
1858                                         continue;
1859
1860                                 group.starting_item = items;
1861                                 group.current_item = 0; // Reset layout.
1862                                 items += items_in_group;
1863                         }
1864                 }
1865
1866                 void LayoutHeader ()
1867                 {
1868                         int x = 0;
1869                         for (int i = 0; i < Columns.Count; i++) {
1870                                 ColumnHeader col = GetReorderedColumn (i);
1871                                 col.X = x;
1872                                 col.Y = 0;
1873                                 col.CalcColumnHeader ();
1874                                 x += col.Wd;
1875                         }
1876
1877                         layout_wd = x;
1878
1879                         if (x < ClientRectangle.Width)
1880                                 x = ClientRectangle.Width;
1881
1882                         if (header_style == ColumnHeaderStyle.None) {
1883                                 header_control.Visible = false;
1884                                 header_control.Size = Size.Empty;
1885                                 layout_wd = ClientRectangle.Width;
1886                         } else {
1887                                 header_control.Width = x;
1888                                 header_control.Height = columns.Count > 0 ? columns [0].Ht : ThemeEngine.Current.ListViewGetHeaderHeight (this, Font);
1889                                 header_control.Visible = true;
1890                         }
1891                 }
1892
1893                 void LayoutDetails ()
1894                 {
1895                         LayoutHeader ();
1896
1897                         if (columns.Count == 0) {
1898                                 item_control.Visible = false;
1899                                 layout_wd = ClientRectangle.Width;
1900                                 layout_ht = ClientRectangle.Height;
1901                                 return;
1902                         }
1903
1904                         item_control.Visible = true;
1905                         item_control.Location = Point.Empty;
1906                         item_control.Width = ClientRectangle.Width;
1907                         AdjustChildrenZOrder ();
1908
1909                         int item_height = GetDetailsItemHeight ();
1910                         ItemSize = new Size (0, item_height); // We only cache Height for details view
1911                         int y = header_control.Height;
1912                         layout_ht = y + (item_height * items.Count);
1913                         if (items.Count > 0 && grid_lines) // some space for bottom gridline
1914                                 layout_ht += 2;
1915
1916                         bool using_groups = UsingGroups;
1917                         if (using_groups) {
1918                                 // Observe that this routines will override our layout_ht value
1919                                 CalculateDetailsGroupItemsCount ();
1920                                 CalculateGroupsLayout (ItemSize, 2, y);
1921                         }
1922
1923                         if (virtual_mode) // no assgination on items is needed
1924                                 return;
1925
1926                         for (int i = 0; i < items.Count; i++) {
1927                                 ListViewItem item = items [i];
1928
1929                                 int display_index;
1930                                 int item_y;
1931
1932                                 if (using_groups) {
1933                                         ListViewGroup group = item.Group;
1934                                         if (group == null)
1935                                                 group = groups.DefaultGroup;
1936
1937                                         int current_item = group.current_item++;
1938                                         Point group_items_loc = group.items_area_location;
1939                                         display_index = group.starting_item + current_item;
1940
1941                                         y = item_y = current_item * (item_height + 2) + group_items_loc.Y;
1942                                         SetItemLocation (display_index, 0, item_y, 0, 0);
1943                                         SetItemAtDisplayIndex (display_index, i);
1944                                 } else
1945                                 {
1946                                         display_index = i;
1947                                         item_y = y;
1948                                         SetItemLocation (i, 0, item_y, 0, 0);
1949                                         y += item_height;
1950                                 }
1951
1952                                 item.Layout ();
1953                                 item.DisplayIndex = display_index;
1954                                 item.SetPosition (new Point (0, item_y));
1955                         }
1956                 }
1957
1958                 // Need to make sure HeaderControl is on top, and we can't simply use BringToFront since
1959                 // these controls are implicit, so we need to re-populate our collection.
1960                 void AdjustChildrenZOrder ()
1961                 {
1962                         SuspendLayout ();
1963                         Controls.ClearImplicit ();
1964                         Controls.AddImplicit (header_control);
1965                         Controls.AddImplicit (item_control);
1966                         Controls.AddImplicit (h_scroll);
1967                         Controls.AddImplicit (v_scroll);
1968                         ResumeLayout ();
1969                 }
1970
1971                 private void AdjustItemsPositionArray (int count)
1972                 {
1973                         // In virtual mode we compute the positions on the fly.
1974                         if (virtual_mode)
1975                                 return;
1976                         if (items_location.Length >= count)
1977                                 return;
1978
1979                         // items_location, items_matrix_location and reordered_items_indices must keep the same length
1980                         count = Math.Max (count, items_location.Length * 2);
1981                         items_location = new Point [count];
1982                         items_matrix_location = new ItemMatrixLocation [count];
1983                         reordered_items_indices = new int [count];
1984                 }
1985
1986                 private void CalculateListView (ListViewAlignment align)
1987                 {
1988                         CalcTextSize ();
1989
1990                         AdjustItemsPositionArray (items.Count);
1991
1992                         switch (view) {
1993                         case View.Details:
1994                                 LayoutDetails ();
1995                                 break;
1996
1997                         case View.SmallIcon:
1998                                 LayoutIcons (SmallIconItemSize, alignment == ListViewAlignment.Left,
1999                                                 ThemeEngine.Current.ListViewHorizontalSpacing, 2);
2000                                 break;
2001
2002                         case View.LargeIcon:
2003                                 LayoutIcons (LargeIconItemSize, alignment == ListViewAlignment.Left,
2004                                         ThemeEngine.Current.ListViewHorizontalSpacing,
2005                                         ThemeEngine.Current.ListViewVerticalSpacing);
2006                                 break;
2007
2008                         case View.List:
2009                                 LayoutIcons (SmallIconItemSize, true,
2010                                                 ThemeEngine.Current.ListViewHorizontalSpacing, 2);
2011                                 break;
2012                         case View.Tile:
2013                                 if (!Application.VisualStylesEnabled)
2014                                         goto case View.LargeIcon;
2015
2016                                 LayoutIcons (TileItemSize, alignment == ListViewAlignment.Left,
2017                                                 ThemeEngine.Current.ListViewHorizontalSpacing,
2018                                                 ThemeEngine.Current.ListViewVerticalSpacing);
2019                                 break;
2020                         }
2021
2022                         CalculateScrollBars ();
2023                 }
2024
2025                 internal Point GetItemLocation (int index)
2026                 {
2027                         Point loc = Point.Empty;
2028                         if (virtual_mode)
2029                                 loc = GetFixedItemLocation (index);
2030                         else
2031                                 loc = items_location [index];
2032
2033                         loc.X -= h_marker; // Adjust to scroll
2034                         loc.Y -= v_marker;
2035
2036                         return loc;
2037                 }
2038
2039                 Point GetFixedItemLocation (int index)
2040                 {
2041                         Point loc = Point.Empty;
2042
2043                         switch (view) {
2044                                 case View.LargeIcon:
2045                                 case View.SmallIcon:
2046                                         loc.X = index % cols * (item_size.Width + x_spacing);
2047                                         loc.Y = index / cols * (item_size.Height + y_spacing);
2048                                         break;
2049                                 case View.List:
2050                                         loc.X = index / rows * (item_size.Width + x_spacing);
2051                                         loc.Y = index % rows * (item_size.Height + y_spacing);
2052                                         break;
2053                                 case View.Details:
2054                                         loc.Y = header_control.Height + (index * item_size.Height);
2055                                         break;
2056                         }
2057
2058                         return loc;
2059                 }
2060
2061                 internal int GetItemIndex (int display_index)
2062                 {
2063                         if (virtual_mode)
2064                                 return display_index; // no reordering in virtual mode.
2065                         return reordered_items_indices [display_index];
2066                 }
2067
2068                 internal ListViewItem GetItemAtDisplayIndex (int display_index)
2069                 {
2070                         // in virtual mode there's no reordering at all.
2071                         if (virtual_mode)
2072                                 return items [display_index];
2073                         return items [reordered_items_indices [display_index]];
2074                 }
2075
2076                 internal void SetItemAtDisplayIndex (int display_index, int index)
2077                 {
2078                         reordered_items_indices [display_index] = index;
2079                 }
2080
2081                 private bool KeySearchString (KeyEventArgs ke)
2082                 {
2083                         int current_tickcnt = Environment.TickCount;
2084                         if (keysearch_tickcnt > 0 && current_tickcnt - keysearch_tickcnt > keysearch_keydelay) {
2085                                 keysearch_text = string.Empty;
2086                         }
2087
2088                         if (!Char.IsLetterOrDigit ((char)ke.KeyCode))
2089                                 return false;
2090
2091                         keysearch_text += (char)ke.KeyCode;
2092                         keysearch_tickcnt = current_tickcnt;
2093
2094                         int prev_focused = FocusedItem == null ? 0 : FocusedItem.DisplayIndex;
2095                         int start = prev_focused + 1 < Items.Count ? prev_focused + 1 : 0;
2096
2097                         ListViewItem item = FindItemWithText (keysearch_text, false, start, true, true);
2098                         if (item != null && prev_focused != item.DisplayIndex) {
2099                                 selected_indices.Clear ();
2100
2101                                 SetFocusedItem (item.DisplayIndex);
2102                                 item.Selected = true;
2103                                 EnsureVisible (GetItemIndex (item.DisplayIndex));
2104                         }
2105
2106                         return true;
2107                 }
2108
2109                 private void OnItemsChanged ()
2110                 {
2111                         ResetSearchString ();
2112                 }
2113
2114                 private void ResetSearchString ()
2115                 {
2116                         keysearch_text = String.Empty;
2117                 }
2118
2119                 int GetAdjustedIndex (Keys key)
2120                 {
2121                         int result = -1;
2122
2123                         if (View == View.Details) {
2124                                 switch (key) {
2125                                 case Keys.Up:
2126                                         result = FocusedItem.DisplayIndex - 1;
2127                                         break;
2128                                 case Keys.Down:
2129                                         result = FocusedItem.DisplayIndex + 1;
2130                                         if (result == items.Count)
2131                                                 result = -1;
2132                                         break;
2133                                 case Keys.PageDown:
2134                                         int last_index = LastVisibleIndex;
2135                                         Rectangle item_rect = new Rectangle (GetItemLocation (last_index), ItemSize);
2136                                         if (item_rect.Bottom > item_control.ClientRectangle.Bottom)
2137                                                 last_index--;
2138                                         if (FocusedItem.DisplayIndex == last_index) {
2139                                                 if (FocusedItem.DisplayIndex < Items.Count - 1) {
2140                                                         int page_size = item_control.Height / ItemSize.Height - 1;
2141                                                         result = FocusedItem.DisplayIndex + page_size - 1;
2142                                                         if (result >= Items.Count)
2143                                                                 result = Items.Count - 1;
2144                                                 }
2145                                         } else
2146                                                 result = last_index;
2147                                         break;
2148                                 case Keys.PageUp:
2149                                         int first_index = FirstVisibleIndex;
2150                                         if (GetItemLocation (first_index).Y < 0)
2151                                                 first_index++;
2152                                         if (FocusedItem.DisplayIndex == first_index) {
2153                                                 if (first_index > 0) {
2154                                                         int page_size = item_control.Height / ItemSize.Height - 1;
2155                                                         result = first_index - page_size + 1;
2156                                                         if (result < 0)
2157                                                                 result = 0;
2158                                                 }
2159                                         } else
2160                                                 result = first_index;
2161                                         break;
2162                                 }
2163                                 return result;
2164                         }
2165
2166                         if (virtual_mode)
2167                                 return GetFixedAdjustedIndex (key);
2168
2169                         ItemMatrixLocation item_matrix_location = items_matrix_location [FocusedItem.DisplayIndex];
2170                         int row = item_matrix_location.Row;
2171                         int col = item_matrix_location.Col;
2172
2173                         int adjusted_index = -1;
2174
2175                         switch (key) {
2176                         case Keys.Left:
2177                                 if (col == 0)
2178                                         return -1;
2179                                 adjusted_index = item_index_matrix [row, col - 1];
2180                                 break;
2181
2182                         case Keys.Right:
2183                                 if (col == (cols - 1))
2184                                         return -1;
2185                                 while (item_index_matrix [row, col + 1] == 0) {
2186                                         row--;
2187                                         if (row < 0)
2188                                                 return -1;
2189                                 }
2190                                 adjusted_index = item_index_matrix [row, col + 1];
2191                                 break;
2192
2193                         case Keys.Up:
2194                                 if (row == 0)
2195                                         return -1;
2196                                 while (item_index_matrix [row - 1, col] == 0 && row != 1) {
2197                                         col--;
2198                                         if (col < 0)
2199                                                 return -1;
2200                                 }
2201                                 adjusted_index = item_index_matrix [row - 1, col];
2202                                 break;
2203
2204                         case Keys.Down:
2205                                 if (row == (rows - 1) || row == Items.Count - 1)
2206                                         return -1;
2207                                 while (item_index_matrix [row + 1, col] == 0) {
2208                                         col--;
2209                                         if (col < 0)
2210                                                 return -1;
2211                                 }
2212                                 adjusted_index = item_index_matrix [row + 1, col];
2213                                 break;
2214
2215                         default:
2216                                 return -1;
2217                         }
2218
2219                         return items [adjusted_index].DisplayIndex;
2220                 }
2221
2222                 // Used for virtual mode, where items *cannot* be re-arranged
2223                 int GetFixedAdjustedIndex (Keys key)
2224                 {
2225                         int result;
2226
2227                         switch (key) {
2228                                 case Keys.Left:
2229                                         if (view == View.List)
2230                                                 result = focused_item_index - rows;
2231                                         else
2232                                                 result = focused_item_index - 1;
2233                                         break;
2234                                 case Keys.Right:
2235                                         if (view == View.List)
2236                                                 result = focused_item_index + rows;
2237                                         else
2238                                                 result = focused_item_index + 1;
2239                                         break;
2240                                 case Keys.Up:
2241                                         if (view != View.List)
2242                                                 result = focused_item_index - cols;
2243                                         else
2244                                                 result = focused_item_index - 1;
2245                                         break;
2246                                 case Keys.Down:
2247                                         if (view != View.List)
2248                                                 result = focused_item_index + cols;
2249                                         else
2250                                                 result = focused_item_index + 1;
2251                                         break;
2252                                 default:
2253                                         return -1;
2254
2255                         }
2256
2257                         if (result < 0 || result >= items.Count)
2258                                 result = focused_item_index;
2259
2260                         return result;
2261                 }
2262
2263                 ListViewItem selection_start;
2264
2265                 private bool SelectItems (ArrayList sel_items)
2266                 {
2267                         bool changed = false;
2268                         foreach (ListViewItem item in SelectedItems)
2269                                 if (!sel_items.Contains (item)) {
2270                                         item.Selected = false;
2271                                         changed = true;
2272                                 }
2273                         foreach (ListViewItem item in sel_items)
2274                                 if (!item.Selected) {
2275                                         item.Selected = true;
2276                                         changed = true;
2277                                 }
2278                         return changed;
2279                 }
2280
2281                 private void UpdateMultiSelection (int index, bool reselect)
2282                 {
2283                         bool shift_pressed = (XplatUI.State.ModifierKeys & Keys.Shift) != 0;
2284                         bool ctrl_pressed = (XplatUI.State.ModifierKeys & Keys.Control) != 0;
2285                         ListViewItem item = GetItemAtDisplayIndex (index);
2286
2287                         if (shift_pressed && selection_start != null) {
2288                                 ArrayList list = new ArrayList ();
2289                                 int start_index = selection_start.DisplayIndex;
2290                                 int start = Math.Min (start_index, index);
2291                                 int end = Math.Max (start_index, index);
2292                                 if (View == View.Details) {
2293                                         for (int i = start; i <= end; i++)
2294                                                 list.Add (GetItemAtDisplayIndex (i));
2295                                 } else {
2296                                         ItemMatrixLocation start_item_matrix_location = items_matrix_location [start];
2297                                         ItemMatrixLocation end_item_matrix_location = items_matrix_location [end];
2298                                         int left = Math.Min (start_item_matrix_location.Col, end_item_matrix_location.Col);
2299                                         int right = Math.Max (start_item_matrix_location.Col, end_item_matrix_location.Col);
2300                                         int top = Math.Min (start_item_matrix_location.Row, end_item_matrix_location.Row);
2301                                         int bottom = Math.Max (start_item_matrix_location.Row, end_item_matrix_location.Row);
2302
2303                                         for (int i = 0; i < items.Count; i++) {
2304                                                 ItemMatrixLocation item_matrix_loc = items_matrix_location [i];
2305
2306                                                 if (item_matrix_loc.Row >= top && item_matrix_loc.Row <= bottom &&
2307                                                                 item_matrix_loc.Col >= left && item_matrix_loc.Col <= right)
2308                                                         list.Add (GetItemAtDisplayIndex (i));
2309                                         }
2310                                 }
2311                                 SelectItems (list);
2312                         } else if (ctrl_pressed) {
2313                                 item.Selected = !item.Selected;
2314                                 selection_start = item;
2315                         } else {
2316                                 if (!reselect) {
2317                                         // do not unselect, and reselect the item
2318                                         foreach (int itemIndex in SelectedIndices) {
2319                                                 if (index == itemIndex)
2320                                                         continue;
2321                                                 items [itemIndex].Selected = false;
2322                                         }
2323                                 } else {
2324                                         SelectedItems.Clear ();
2325                                         item.Selected = true;
2326                                 }
2327                                 selection_start = item;
2328                         }
2329                 }
2330
2331                 internal override bool InternalPreProcessMessage (ref Message msg)
2332                 {
2333                         if (msg.Msg == (int)Msg.WM_KEYDOWN) {
2334                                 Keys key_data = (Keys)msg.WParam.ToInt32();
2335
2336                                 HandleNavKeys (key_data);
2337                         }
2338
2339                         return base.InternalPreProcessMessage (ref msg);
2340                 }
2341
2342                 bool HandleNavKeys (Keys key_data)
2343                 {
2344                         if (Items.Count == 0 || !item_control.Visible)
2345                                 return false;
2346
2347                         if (FocusedItem == null)
2348                                 SetFocusedItem (0);
2349
2350                         switch (key_data) {
2351                         case Keys.End:
2352                                 SelectIndex (Items.Count - 1);
2353                                 break;
2354
2355                         case Keys.Home:
2356                                 SelectIndex (0);
2357                                 break;
2358
2359                         case Keys.Left:
2360                         case Keys.Right:
2361                         case Keys.Up:
2362                         case Keys.Down:
2363                         case Keys.PageUp:
2364                         case Keys.PageDown:
2365                                 SelectIndex (GetAdjustedIndex (key_data));
2366                                 break;
2367
2368                         case Keys.Space:
2369                                 SelectIndex (focused_item_index);
2370                                 ToggleItemsCheckState ();
2371                                 break;
2372                         case Keys.Enter:
2373                                 if (selected_indices.Count > 0)
2374                                         OnItemActivate (EventArgs.Empty);
2375                                 break;
2376
2377                         default:
2378                                 return false;
2379                         }
2380
2381                         return true;
2382                 }
2383
2384                 void ToggleItemsCheckState ()
2385                 {
2386                         if (!CheckBoxes)
2387                                 return;
2388
2389                         // Don't modify check state if StateImageList has less than 2 elements
2390                         if (StateImageList != null && StateImageList.Images.Count < 2)
2391                                 return;
2392
2393                         if (SelectedIndices.Count > 0) {
2394                                 for (int i = 0; i < SelectedIndices.Count; i++) {
2395                                         ListViewItem item = Items [SelectedIndices [i]];
2396                                         item.Checked = !item.Checked;
2397                                 }
2398                                 return;
2399                         }
2400
2401                         if (FocusedItem != null) {
2402                                 FocusedItem.Checked = !FocusedItem.Checked;
2403                                 SelectIndex (FocusedItem.Index);
2404                         }
2405                 }
2406
2407                 void SelectIndex (int display_index)
2408                 {
2409                         if (display_index == -1)
2410                                 return;
2411
2412                         if (MultiSelect)
2413                                 UpdateMultiSelection (display_index, true);
2414                         else if (!GetItemAtDisplayIndex (display_index).Selected)
2415                                 GetItemAtDisplayIndex (display_index).Selected = true;
2416
2417                         SetFocusedItem (display_index);
2418                         EnsureVisible (GetItemIndex (display_index)); // Index in Items collection, not display index
2419                 }
2420
2421                 private void ListView_KeyDown (object sender, KeyEventArgs ke)
2422                 {
2423                         if (ke.Handled || Items.Count == 0 || !item_control.Visible)
2424                                 return;
2425
2426                         if (ke.Alt || ke.Control)
2427                                 return;
2428
2429                         ke.Handled = KeySearchString (ke);
2430                 }
2431
2432                 private MouseEventArgs TranslateMouseEventArgs (MouseEventArgs args)
2433                 {
2434                         Point loc = PointToClient (Control.MousePosition);
2435                         return new MouseEventArgs (args.Button, args.Clicks, loc.X, loc.Y, args.Delta);
2436                 }
2437
2438                 internal class ItemControl : Control {
2439
2440                         ListView owner;
2441                         ListViewItem clicked_item;
2442                         ListViewItem last_clicked_item;
2443                         bool hover_processed = false;
2444                         bool checking = false;
2445                         ListViewItem prev_hovered_item;
2446                         ListViewItem prev_tooltip_item;
2447                         int clicks;
2448                         Point drag_begin = new Point (-1, -1);
2449                         internal int dragged_item_index = -1;
2450
2451                         ListViewLabelEditTextBox edit_text_box;
2452                         internal ListViewItem edit_item;
2453                         LabelEditEventArgs edit_args;
2454
2455                         public ItemControl (ListView owner)
2456                         {
2457                                 this.owner = owner;
2458                                 this.SetStyle (ControlStyles.DoubleBuffer, true);
2459                                 DoubleClick += new EventHandler(ItemsDoubleClick);
2460                                 MouseDown += new MouseEventHandler(ItemsMouseDown);
2461                                 MouseMove += new MouseEventHandler(ItemsMouseMove);
2462                                 MouseHover += new EventHandler(ItemsMouseHover);
2463                                 MouseUp += new MouseEventHandler(ItemsMouseUp);
2464                         }
2465
2466                         void ItemsDoubleClick (object sender, EventArgs e)
2467                         {
2468                                 if (owner.activation == ItemActivation.Standard)
2469                                         owner.OnItemActivate (EventArgs.Empty);
2470                         }
2471
2472                         enum BoxSelect {
2473                                 None,
2474                                 Normal,
2475                                 Shift,
2476                                 Control
2477                         }
2478
2479                         BoxSelect box_select_mode = BoxSelect.None;
2480                         IList prev_selection;
2481                         Point box_select_start;
2482
2483                         Rectangle box_select_rect;
2484                         internal Rectangle BoxSelectRectangle {
2485                                 get { return box_select_rect; }
2486                                 set {
2487                                         if (box_select_rect == value)
2488                                                 return;
2489
2490                                         InvalidateBoxSelectRect ();
2491                                         box_select_rect = value;
2492                                         InvalidateBoxSelectRect ();
2493                                 }
2494                         }
2495
2496                         void InvalidateBoxSelectRect ()
2497                         {
2498                                 if (BoxSelectRectangle.Size.IsEmpty)
2499                                         return;
2500
2501                                 Rectangle edge = BoxSelectRectangle;
2502                                 edge.X -= 1;
2503                                 edge.Y -= 1;
2504                                 edge.Width += 2;
2505                                 edge.Height = 2;
2506                                 Invalidate (edge);
2507                                 edge.Y = BoxSelectRectangle.Bottom - 1;
2508                                 Invalidate (edge);
2509                                 edge.Y = BoxSelectRectangle.Y - 1;
2510                                 edge.Width = 2;
2511                                 edge.Height = BoxSelectRectangle.Height + 2;
2512                                 Invalidate (edge);
2513                                 edge.X = BoxSelectRectangle.Right - 1;
2514                                 Invalidate (edge);
2515                         }
2516
2517                         private Rectangle CalculateBoxSelectRectangle (Point pt)
2518                         {
2519                                 int left = Math.Min (box_select_start.X, pt.X);
2520                                 int right = Math.Max (box_select_start.X, pt.X);
2521                                 int top = Math.Min (box_select_start.Y, pt.Y);
2522                                 int bottom = Math.Max (box_select_start.Y, pt.Y);
2523                                 return Rectangle.FromLTRB (left, top, right, bottom);
2524                         }
2525
2526                         bool BoxIntersectsItem (int index)
2527                         {
2528                                 Rectangle r = new Rectangle (owner.GetItemLocation (index), owner.ItemSize);
2529                                 if (owner.View != View.Details) {
2530                                         r.X += r.Width / 4;
2531                                         r.Y += r.Height / 4;
2532                                         r.Width /= 2;
2533                                         r.Height /= 2;
2534                                 }
2535                                 return BoxSelectRectangle.IntersectsWith (r);
2536                         }
2537
2538                         bool BoxIntersectsText (int index)
2539                         {
2540                                 Rectangle r = owner.GetItemAtDisplayIndex (index).TextBounds;
2541                                 return BoxSelectRectangle.IntersectsWith (r);
2542                         }
2543
2544                         ArrayList BoxSelectedItems {
2545                                 get {
2546                                         ArrayList result = new ArrayList ();
2547                                         for (int i = 0; i < owner.Items.Count; i++) {
2548                                                 bool intersects;
2549                                                 // Can't iterate over specific items properties in virtualmode
2550                                                 if (owner.View == View.Details && !owner.FullRowSelect && !owner.VirtualMode)
2551                                                         intersects = BoxIntersectsText (i);
2552                                                 else
2553                                                         intersects = BoxIntersectsItem (i);
2554
2555                                                 if (intersects)
2556                                                         result.Add (owner.GetItemAtDisplayIndex (i));
2557                                         }
2558                                         return result;
2559                                 }
2560                         }
2561
2562                         private bool PerformBoxSelection (Point pt)
2563                         {
2564                                 if (box_select_mode == BoxSelect.None)
2565                                         return false;
2566
2567                                 BoxSelectRectangle = CalculateBoxSelectRectangle (pt);
2568
2569                                 ArrayList box_items = BoxSelectedItems;
2570
2571                                 ArrayList items;
2572
2573                                 switch (box_select_mode) {
2574
2575                                 case BoxSelect.Normal:
2576                                         items = box_items;
2577                                         break;
2578
2579                                 case BoxSelect.Control:
2580                                         items = new ArrayList ();
2581                                         foreach (int index in prev_selection)
2582                                                 if (!box_items.Contains (owner.Items [index]))
2583                                                         items.Add (owner.Items [index]);
2584                                         foreach (ListViewItem item in box_items)
2585                                                 if (!prev_selection.Contains (item.Index))
2586                                                         items.Add (item);
2587                                         break;
2588
2589                                 case BoxSelect.Shift:
2590                                         items = box_items;
2591                                         foreach (ListViewItem item in box_items)
2592                                                 prev_selection.Remove (item.Index);
2593                                         foreach (int index in prev_selection)
2594                                                 items.Add (owner.Items [index]);
2595                                         break;
2596
2597                                 default:
2598                                         throw new Exception ("Unexpected Selection mode: " + box_select_mode);
2599                                 }
2600
2601                                 SuspendLayout ();
2602                                 owner.SelectItems (items);
2603                                 ResumeLayout ();
2604
2605                                 return true;
2606                         }
2607
2608                         private void ItemsMouseDown (object sender, MouseEventArgs me)
2609                         {
2610                                 owner.OnMouseDown (owner.TranslateMouseEventArgs (me));
2611                                 if (owner.items.Count == 0)
2612                                         return;
2613
2614                                 bool box_selecting = false;
2615                                 Size item_size = owner.ItemSize;
2616                                 Point pt = new Point (me.X, me.Y);
2617                                 for (int i = 0; i < owner.items.Count; i++) {
2618                                         Rectangle item_rect = new Rectangle (owner.GetItemLocation (i), item_size);
2619                                         if (!item_rect.Contains (pt))
2620                                                 continue;
2621
2622                                         // Actual item in 'i' position
2623                                         ListViewItem item = owner.GetItemAtDisplayIndex (i);
2624
2625                                         if (item.CheckRectReal.Contains (pt)) {
2626                                                 // Don't modify check state if we have only one image
2627                                                 // and if we are in 1.1 profile only take into account
2628                                                 // double clicks
2629                                                 if (owner.StateImageList != null && owner.StateImageList.Images.Count < 2
2630                                                                 )
2631                                                         return;
2632
2633                                                 // Generate an extra ItemCheck event when we got two clicks
2634                                                 // (Match weird .Net behaviour)
2635                                                 if (me.Clicks == 2)
2636                                                         item.Checked = !item.Checked;
2637
2638                                                 item.Checked = !item.Checked;
2639                                                 checking = true;
2640                                                 return;
2641                                         }
2642
2643                                         if (owner.View == View.Details) {
2644                                                 bool over_text = item.TextBounds.Contains (pt);
2645                                                 if (owner.FullRowSelect) {
2646                                                         clicked_item = item;
2647                                                         bool over_item_column = (me.X > owner.Columns[0].X && me.X < owner.Columns[0].X + owner.Columns[0].Width);
2648                                                         if (!over_text && over_item_column && owner.MultiSelect)
2649                                                                 box_selecting = true;
2650                                                 } else if (over_text)
2651                                                         clicked_item = item;
2652                                                 else
2653                                                         owner.SetFocusedItem (i);
2654                                         } else
2655                                                 clicked_item = item;
2656
2657                                         break;
2658                                 }
2659
2660
2661                                 if (clicked_item != null) {
2662                                         bool changed = !clicked_item.Selected;
2663                                         if (me.Button == MouseButtons.Left || (XplatUI.State.ModifierKeys == Keys.None && changed))
2664                                                 owner.SetFocusedItem (clicked_item.DisplayIndex);
2665
2666                                         if (owner.MultiSelect) {
2667                                                 bool reselect = (!owner.LabelEdit || changed);
2668                                                 if (me.Button == MouseButtons.Left || (XplatUI.State.ModifierKeys == Keys.None && changed))
2669                                                         owner.UpdateMultiSelection (clicked_item.DisplayIndex, reselect);
2670                                         } else {
2671                                                 clicked_item.Selected = true;
2672                                                 // Side-effects to setting Selected can possibly result in ItemsMouseUp() being called
2673                                                 // and clicked_item being set to null.  (See Xamarin bug 23591.)  In such a case, assume
2674                                                 // that there's nothing more we can do here.
2675                                                 if (clicked_item == null)
2676                                                         return;
2677                                         }
2678
2679                                         if (owner.VirtualMode && changed) {
2680                                                 // Broken event - It's not fired from Item.Selected also
2681                                                 ListViewVirtualItemsSelectionRangeChangedEventArgs args =
2682                                                         new ListViewVirtualItemsSelectionRangeChangedEventArgs (0, owner.items.Count - 1, false);
2683
2684                                                 owner.OnVirtualItemsSelectionRangeChanged (args);
2685                                         }
2686                                         // Report clicks only if the item was clicked. On MS the
2687                                         // clicks are only raised if you click an item
2688                                         clicks = me.Clicks;
2689                                         if (me.Clicks > 1) {
2690                                                 if (owner.CheckBoxes)
2691                                                         clicked_item.Checked = !clicked_item.Checked;
2692                                         } else if (me.Clicks == 1) {
2693                                                 if (owner.LabelEdit && !changed)
2694                                                         BeginEdit (clicked_item); // this is probably not the correct place to execute BeginEdit
2695                                         }
2696
2697                                         drag_begin = me.Location;
2698                                         dragged_item_index = clicked_item.Index;
2699                                 } else {
2700                                         if (owner.MultiSelect)
2701                                                 box_selecting = true;
2702                                         else if (owner.SelectedItems.Count > 0)
2703                                                 owner.SelectedItems.Clear ();
2704                                 }
2705
2706                                 if (box_selecting) {
2707                                         Keys mods = XplatUI.State.ModifierKeys;
2708                                         if ((mods & Keys.Shift) != 0)
2709                                                 box_select_mode = BoxSelect.Shift;
2710                                         else if ((mods & Keys.Control) != 0)
2711                                                 box_select_mode = BoxSelect.Control;
2712                                         else
2713                                                 box_select_mode = BoxSelect.Normal;
2714                                         box_select_start = pt;
2715                                         prev_selection = owner.SelectedIndices.List.Clone () as IList;
2716                                 }
2717                         }
2718
2719                         private void ItemsMouseMove (object sender, MouseEventArgs me)
2720                         {
2721                                 bool done = PerformBoxSelection (new Point (me.X, me.Y));
2722
2723                                 owner.OnMouseMove (owner.TranslateMouseEventArgs (me));
2724
2725                                 if (done)
2726                                         return;
2727                                 if ((me.Button != MouseButtons.Left && me.Button != MouseButtons.Right) &&
2728                                         !hover_processed && owner.Activation != ItemActivation.OneClick
2729                                         && !owner.ShowItemToolTips
2730                                                 )
2731                                         return;
2732
2733                                 Point pt = PointToClient (Control.MousePosition);
2734                                 ListViewItem item = owner.GetItemAt (pt.X, pt.Y);
2735
2736                                 if (hover_processed && item != null && item != prev_hovered_item) {
2737                                         hover_processed = false;
2738                                         XplatUI.ResetMouseHover (Handle);
2739                                 }
2740
2741                                 // Need to invalidate the item in HotTracking to show/hide the underline style
2742                                 if (owner.Activation == ItemActivation.OneClick) {
2743                                         if (item == null && owner.HotItemIndex != -1) {
2744                                                 if (owner.HotTracking)
2745                                                         Invalidate (owner.Items [owner.HotItemIndex].Bounds); // Previous one
2746
2747                                                 Cursor = Cursors.Default;
2748                                                 owner.HotItemIndex = -1;
2749                                         } else if (item != null && owner.HotItemIndex == -1) {
2750                                                 if (owner.HotTracking)
2751                                                         Invalidate (item.Bounds);
2752
2753                                                 Cursor = Cursors.Hand;
2754                                                 owner.HotItemIndex = item.Index;
2755                                         }
2756                                 }
2757
2758                                 if (me.Button == MouseButtons.Left || me.Button == MouseButtons.Right) {
2759                                         if (drag_begin != new Point (-1, -1)) {
2760                                                 Rectangle r = new Rectangle (drag_begin, SystemInformation.DragSize);
2761                                                 if (!r.Contains (me.X, me.Y)) {
2762                                                         ListViewItem dragged_item  = owner.items [dragged_item_index];
2763                                                         owner.OnItemDrag (new ItemDragEventArgs (me.Button, dragged_item));
2764
2765                                                         drag_begin = new Point (-1, -1);
2766                                                         dragged_item_index = -1;
2767                                                 }
2768                                         }
2769                                 }
2770
2771                                 if (owner.ShowItemToolTips) {
2772                                         if (item == null) {
2773                                                 owner.item_tooltip.Active = false;
2774                                                 prev_tooltip_item = null;
2775                                         } else if (item != prev_tooltip_item && item.ToolTipText.Length > 0) {
2776                                                 owner.item_tooltip.Active = true;
2777                                                 owner.item_tooltip.SetToolTip (owner, item.ToolTipText);
2778                                                 prev_tooltip_item = item;
2779                                         }
2780                                 }
2781
2782                         }
2783
2784                         private void ItemsMouseHover (object sender, EventArgs e)
2785                         {
2786                                 if (owner.hover_pending) {
2787                                         owner.OnMouseHover (e);
2788                                         owner.hover_pending = false;
2789                                 }
2790
2791                                 if (Capture)
2792                                         return;
2793
2794                                 hover_processed = true;
2795                                 Point pt = PointToClient (Control.MousePosition);
2796                                 ListViewItem item = owner.GetItemAt (pt.X, pt.Y);
2797                                 if (item == null)
2798                                         return;
2799
2800                                 prev_hovered_item = item;
2801
2802                                 if (owner.HoverSelection) {
2803                                         if (owner.MultiSelect)
2804                                                 owner.UpdateMultiSelection (item.Index, true);
2805                                         else
2806                                                 item.Selected = true;
2807
2808                                         owner.SetFocusedItem (item.DisplayIndex);
2809                                         Select (); // Make sure we have the focus, since MouseHover doesn't give it to us
2810                                 }
2811
2812                                 owner.OnItemMouseHover (new ListViewItemMouseHoverEventArgs (item));
2813                         }
2814
2815                         void HandleClicks (MouseEventArgs me)
2816                         {
2817                                 // if the click is not on an item,
2818                                 // clicks remains as 0
2819                                 if (clicks > 1) {
2820                                         owner.OnDoubleClick (EventArgs.Empty);
2821                                         owner.OnMouseDoubleClick (me);
2822                                 } else if (clicks == 1) {
2823                                         owner.OnClick (EventArgs.Empty);
2824                                         owner.OnMouseClick (me);
2825                                 }
2826
2827                                 clicks = 0;
2828                         }
2829
2830                         private void ItemsMouseUp (object sender, MouseEventArgs me)
2831                         {
2832                                 MouseEventArgs owner_me = owner.TranslateMouseEventArgs (me);
2833                                 HandleClicks (owner_me);
2834
2835                                 Capture = false;
2836                                 if (owner.Items.Count == 0) {
2837                                         ResetMouseState ();
2838                                         owner.OnMouseUp (owner_me);
2839                                         return;
2840                                 }
2841
2842                                 Point pt = new Point (me.X, me.Y);
2843
2844                                 Rectangle rect = Rectangle.Empty;
2845                                 if (clicked_item != null) {
2846                                         if (owner.view == View.Details && !owner.full_row_select)
2847                                                 rect = clicked_item.GetBounds (ItemBoundsPortion.Label);
2848                                         else
2849                                                 rect = clicked_item.Bounds;
2850
2851                                         if (rect.Contains (pt)) {
2852                                                 switch (owner.activation) {
2853                                                 case ItemActivation.OneClick:
2854                                                         owner.OnItemActivate (EventArgs.Empty);
2855                                                         break;
2856
2857                                                 case ItemActivation.TwoClick:
2858                                                         if (last_clicked_item == clicked_item) {
2859                                                                 owner.OnItemActivate (EventArgs.Empty);
2860                                                                 last_clicked_item = null;
2861                                                         } else
2862                                                                 last_clicked_item = clicked_item;
2863                                                         break;
2864                                                 default:
2865                                                         // DoubleClick activation is handled in another handler
2866                                                         break;
2867                                                 }
2868                                         }
2869                                 } else if (!checking && owner.SelectedItems.Count > 0 && BoxSelectRectangle.Size.IsEmpty) {
2870                                         // Need this to clean up background clicks
2871                                         owner.SelectedItems.Clear ();
2872                                 }
2873
2874                                 ResetMouseState ();
2875                                 owner.OnMouseUp (owner_me);
2876                         }
2877
2878                         private void ResetMouseState ()
2879                         {
2880                                 clicked_item = null;
2881                                 box_select_start = Point.Empty;
2882                                 BoxSelectRectangle = Rectangle.Empty;
2883                                 prev_selection = null;
2884                                 box_select_mode = BoxSelect.None;
2885                                 checking = false;
2886
2887                                 // Clean these bits in case the mouse buttons were
2888                                 // released before firing ItemDrag
2889                                 dragged_item_index = -1;
2890                                 drag_begin = new Point (-1, -1);
2891                         }
2892
2893                         private void LabelEditFinished (object sender, EventArgs e)
2894                         {
2895                                 EndEdit (edit_item);
2896                         }
2897
2898                         private void LabelEditCancelled (object sender, EventArgs e)
2899                         {
2900                                 edit_args.SetLabel (null);
2901                                 EndEdit (edit_item);
2902                         }
2903
2904                         private void LabelTextChanged (object sender, EventArgs e)
2905                         {
2906                                 if (edit_args != null)
2907                                         edit_args.SetLabel (edit_text_box.Text);
2908                         }
2909
2910                         internal void BeginEdit (ListViewItem item)
2911                         {
2912                                 if (edit_item != null)
2913                                         EndEdit (edit_item);
2914
2915                                 if (edit_text_box == null) {
2916                                         edit_text_box = new ListViewLabelEditTextBox ();
2917                                         edit_text_box.BorderStyle = BorderStyle.FixedSingle;
2918                                         edit_text_box.EditingCancelled += new EventHandler (LabelEditCancelled);
2919                                         edit_text_box.EditingFinished += new EventHandler (LabelEditFinished);
2920                                         edit_text_box.TextChanged += new EventHandler (LabelTextChanged);
2921                                         edit_text_box.Visible = false;
2922                                         Controls.Add (edit_text_box);
2923                                 }
2924
2925                                 item.EnsureVisible();
2926
2927                                 edit_text_box.Reset ();
2928
2929                                 switch (owner.view) {
2930                                         case View.List:
2931                                         case View.SmallIcon:
2932                                         case View.Details:
2933                                                 edit_text_box.TextAlign = HorizontalAlignment.Left;
2934                                                 edit_text_box.Bounds = item.GetBounds (ItemBoundsPortion.Label);
2935                                                 SizeF sizef = TextRenderer.MeasureString (item.Text, item.Font);
2936                                                 edit_text_box.Width = (int)sizef.Width + 4;
2937                                                 edit_text_box.MaxWidth = owner.ClientRectangle.Width - edit_text_box.Bounds.X;
2938                                                 edit_text_box.WordWrap = false;
2939                                                 edit_text_box.Multiline = false;
2940                                                 break;
2941                                         case View.LargeIcon:
2942                                                 edit_text_box.TextAlign = HorizontalAlignment.Center;
2943                                                 edit_text_box.Bounds = item.GetBounds (ItemBoundsPortion.Label);
2944                                                 sizef = TextRenderer.MeasureString (item.Text, item.Font);
2945                                                 edit_text_box.Width = (int)sizef.Width + 4;
2946                                                 edit_text_box.MaxWidth = item.GetBounds(ItemBoundsPortion.Entire).Width;
2947                                                 edit_text_box.MaxHeight = owner.ClientRectangle.Height - edit_text_box.Bounds.Y;
2948                                                 edit_text_box.WordWrap = true;
2949                                                 edit_text_box.Multiline = true;
2950                                                 break;
2951                                 }
2952
2953                                 edit_item = item;
2954
2955                                 edit_text_box.Text = item.Text;
2956                                 edit_text_box.Font = item.Font;
2957                                 edit_text_box.Visible = true;
2958                                 edit_text_box.Focus ();
2959                                 edit_text_box.SelectAll ();
2960
2961                                 edit_args = new LabelEditEventArgs (owner.Items.IndexOf (edit_item));
2962                                 owner.OnBeforeLabelEdit (edit_args);
2963
2964                                 if (edit_args.CancelEdit)
2965                                         EndEdit (item);
2966                         }
2967
2968                         internal void CancelEdit (ListViewItem item)
2969                         {
2970                                 // do nothing if there's no item being edited, or if the
2971                                 // item being edited is not the one passed in
2972                                 if (edit_item == null || edit_item != item)
2973                                         return;
2974
2975                                 edit_args.SetLabel (null);
2976                                 EndEdit (item);
2977                         }
2978
2979                         internal void EndEdit (ListViewItem item)
2980                         {
2981                                 // do nothing if there's no item being edited, or if the
2982                                 // item being edited is not the one passed in
2983                                 if (edit_item == null || edit_item != item)
2984                                         return;
2985
2986                                 if (edit_text_box != null) {
2987                                         if (edit_text_box.Visible)
2988                                                 edit_text_box.Visible = false;
2989                                         // ensure listview gets focus
2990                                         owner.Focus ();
2991                                 }
2992
2993                                 // Same as TreeView.EndEdit: need to have focus in synch
2994                                 Application.DoEvents ();
2995
2996                                 //
2997                                 // Create a new instance, since we could get a call to BeginEdit
2998                                 // from the handler and have fields out of synch
2999                                 //
3000                                 LabelEditEventArgs args = new LabelEditEventArgs (item.Index, edit_args.Label);
3001                                 edit_item = null;
3002
3003                                 owner.OnAfterLabelEdit (args);
3004                                 if (!args.CancelEdit && args.Label != null)
3005                                         item.Text = args.Label;
3006                         }
3007
3008                         internal override void OnPaintInternal (PaintEventArgs pe)
3009                         {
3010                                 ThemeEngine.Current.DrawListViewItems (pe.Graphics, pe.ClipRectangle, owner);
3011                         }
3012
3013                         protected override void WndProc (ref Message m)
3014                         {
3015                                 switch ((Msg)m.Msg) {
3016                                 case Msg.WM_KILLFOCUS:
3017                                         owner.Select (false, true);
3018                                         break;
3019                                 case Msg.WM_SETFOCUS:
3020                                         owner.Select (false, true);
3021                                         break;
3022                                 case Msg.WM_LBUTTONDOWN:
3023                                         if (!Focused)
3024                                                 owner.Select (false, true);
3025                                         break;
3026                                 case Msg.WM_RBUTTONDOWN:
3027                                         if (!Focused)
3028                                                 owner.Select (false, true);
3029                                         break;
3030                                 default:
3031                                         break;
3032                                 }
3033                                 base.WndProc (ref m);
3034                         }
3035                 }
3036
3037                 internal class ListViewLabelEditTextBox : TextBox
3038                 {
3039                         int max_width = -1;
3040                         int min_width = -1;
3041
3042                         int max_height = -1;
3043                         int min_height = -1;
3044
3045                         int old_number_lines = 1;
3046
3047                         SizeF text_size_one_char;
3048
3049                         public ListViewLabelEditTextBox ()
3050                         {
3051                                 min_height = DefaultSize.Height;
3052                                 text_size_one_char = TextRenderer.MeasureString ("B", Font);
3053                         }
3054
3055                         public int MaxWidth {
3056                                 set {
3057                                         if (value < min_width)
3058                                                 max_width = min_width;
3059                                         else
3060                                                 max_width = value;
3061                                 }
3062                         }
3063
3064                         public int MaxHeight {
3065                                 set {
3066                                         if (value < min_height)
3067                                                 max_height = min_height;
3068                                         else
3069                                                 max_height = value;
3070                                 }
3071                         }
3072
3073                         public new int Width {
3074                                 get {
3075                                         return base.Width;
3076                                 }
3077                                 set {
3078                                         min_width = value;
3079                                         base.Width = value;
3080                                 }
3081                         }
3082
3083                         public override Font Font {
3084                                 get {
3085                                         return base.Font;
3086                                 }
3087                                 set {
3088                                         base.Font = value;
3089                                         text_size_one_char = TextRenderer.MeasureString ("B", Font);
3090                                 }
3091                         }
3092
3093                         protected override void OnTextChanged (EventArgs e)
3094                         {
3095                                 SizeF text_size = TextRenderer.MeasureString (Text, Font);
3096
3097                                 int new_width = (int)text_size.Width + 8;
3098
3099                                 if (!Multiline)
3100                                         ResizeTextBoxWidth (new_width);
3101                                 else {
3102                                         if (Width != max_width)
3103                                                 ResizeTextBoxWidth (new_width);
3104
3105                                         int number_lines = Lines.Length;
3106
3107                                         if (number_lines != old_number_lines) {
3108                                                 int new_height = number_lines * (int)text_size_one_char.Height + 4;
3109                                                 old_number_lines = number_lines;
3110
3111                                                 ResizeTextBoxHeight (new_height);
3112                                         }
3113                                 }
3114
3115                                 base.OnTextChanged (e);
3116                         }
3117
3118                         protected override bool IsInputKey (Keys key_data)
3119                         {
3120                                 if ((key_data & Keys.Alt) == 0) {
3121                                         switch (key_data & Keys.KeyCode) {
3122                                                 case Keys.Enter:
3123                                                         return true;
3124                                                 case Keys.Escape:
3125                                                         return true;
3126                                         }
3127                                 }
3128                                 return base.IsInputKey (key_data);
3129                         }
3130
3131                         protected override void OnKeyDown (KeyEventArgs e)
3132                         {
3133                                 if (!Visible)
3134                                         return;
3135
3136                                 switch (e.KeyCode) {
3137                                 case Keys.Return:
3138                                         Visible = false;
3139                                         e.Handled = true;
3140                                         OnEditingFinished (e);
3141                                         break;
3142                                 case Keys.Escape:
3143                                         Visible = false;
3144                                         e.Handled = true;
3145                                         OnEditingCancelled (e);
3146                                         break;
3147                                 }
3148                         }
3149
3150                         protected override void OnLostFocus (EventArgs e)
3151                         {
3152                                 if (Visible) {
3153                                         OnEditingFinished (e);
3154                                 }
3155                         }
3156
3157                         protected void OnEditingCancelled (EventArgs e)
3158                         {
3159                                 EventHandler eh = (EventHandler)(Events [EditingCancelledEvent]);
3160                                 if (eh != null)
3161                                         eh (this, e);
3162                         }
3163
3164                         protected void OnEditingFinished (EventArgs e)
3165                         {
3166                                 EventHandler eh = (EventHandler)(Events [EditingFinishedEvent]);
3167                                 if (eh != null)
3168                                         eh (this, e);
3169                         }
3170
3171                         private void ResizeTextBoxWidth (int new_width)
3172                         {
3173                                 if (new_width > max_width)
3174                                         base.Width = max_width;
3175                                 else
3176                                 if (new_width >= min_width)
3177                                         base.Width = new_width;
3178                                 else
3179                                         base.Width = min_width;
3180                         }
3181
3182                         private void ResizeTextBoxHeight (int new_height)
3183                         {
3184                                 if (new_height > max_height)
3185                                         base.Height = max_height;
3186                                 else
3187                                 if (new_height >= min_height)
3188                                         base.Height = new_height;
3189                                 else
3190                                         base.Height = min_height;
3191                         }
3192
3193                         public void Reset ()
3194                         {
3195                                 max_width = -1;
3196                                 min_width = -1;
3197
3198                                 max_height = -1;
3199
3200                                 old_number_lines = 1;
3201
3202                                 Text = String.Empty;
3203
3204                                 Size = DefaultSize;
3205                         }
3206
3207                         static object EditingCancelledEvent = new object ();
3208                         public event EventHandler EditingCancelled {
3209                                 add { Events.AddHandler (EditingCancelledEvent, value); }
3210                                 remove { Events.RemoveHandler (EditingCancelledEvent, value); }
3211                         }
3212
3213                         static object EditingFinishedEvent = new object ();
3214                         public event EventHandler EditingFinished {
3215                                 add { Events.AddHandler (EditingFinishedEvent, value); }
3216                                 remove { Events.RemoveHandler (EditingFinishedEvent, value); }
3217                         }
3218                 }
3219
3220                 internal override void OnPaintInternal (PaintEventArgs pe)
3221                 {
3222                         if (updating)
3223                                 return;
3224
3225                         CalculateScrollBars ();
3226                 }
3227
3228                 void FocusChanged (object o, EventArgs args)
3229                 {
3230                         if (Items.Count == 0)
3231                                 return;
3232
3233                         if (FocusedItem == null)
3234                                 SetFocusedItem (0);
3235
3236                         ListViewItem focused_item = FocusedItem;
3237
3238                         if (focused_item.ListView != null) {
3239                                 focused_item.Invalidate ();
3240                                 focused_item.Layout ();
3241                                 focused_item.Invalidate ();
3242                         }
3243                 }
3244
3245                 private void ListView_Invalidated (object sender, InvalidateEventArgs e)
3246                 {
3247                         // When the ListView is invalidated, we need to invalidate
3248                         // the child controls.
3249                         header_control.Invalidate ();
3250                         item_control.Invalidate ();
3251                 }
3252
3253                 private void ListView_MouseEnter (object sender, EventArgs args)
3254                 {
3255                         hover_pending = true; // Need a hover event for every Enter/Leave cycle
3256                 }
3257
3258                 private void ListView_MouseWheel (object sender, MouseEventArgs me)
3259                 {
3260                         if (Items.Count == 0)
3261                                 return;
3262
3263                         int lines = me.Delta / 120;
3264
3265                         if (lines == 0)
3266                                 return;
3267
3268                         switch (View) {
3269                         case View.Details:
3270                         case View.SmallIcon:
3271                                 Scroll (v_scroll, -ItemSize.Height * SystemInformation.MouseWheelScrollLines * lines);
3272                                 break;
3273                         case View.LargeIcon:
3274                                 Scroll (v_scroll, -(ItemSize.Height + ThemeEngine.Current.ListViewVerticalSpacing)  * lines);
3275                                 break;
3276                         case View.List:
3277                                 Scroll (h_scroll, -ItemSize.Width * lines);
3278                                 break;
3279                         case View.Tile:
3280                                 if (!Application.VisualStylesEnabled)
3281                                         goto case View.LargeIcon;
3282
3283                                 Scroll (v_scroll, -(ItemSize.Height + ThemeEngine.Current.ListViewVerticalSpacing) * 2 * lines);
3284                                 break;
3285                         }
3286                 }
3287
3288                 private void ListView_SizeChanged (object sender, EventArgs e)
3289                 {
3290                         Redraw (true);
3291                 }
3292
3293                 private void SetFocusedItem (int display_index)
3294                 {
3295                         if (display_index != -1)
3296                                 GetItemAtDisplayIndex (display_index).Focused = true;
3297                         else if (focused_item_index != -1 && focused_item_index < items.Count) // Previous focused item
3298                                 GetItemAtDisplayIndex (focused_item_index).Focused = false;
3299                         focused_item_index = display_index;
3300                         if (display_index == -1)
3301                                 OnUIAFocusedItemChanged ();
3302                                 // otherwise the event will have been fired
3303                                 // when the ListViewItem's Focused was set
3304                 }
3305
3306                 private void HorizontalScroller (object sender, EventArgs e)
3307                 {
3308                         item_control.EndEdit (item_control.edit_item);
3309
3310                         // Avoid unnecessary flickering, when button is
3311                         // kept pressed at the end
3312                         if (h_marker != h_scroll.Value) {
3313
3314                                 int pixels = h_marker - h_scroll.Value;
3315
3316                                 h_marker = h_scroll.Value;
3317                                 if (header_control.Visible)
3318                                         XplatUI.ScrollWindow (header_control.Handle, pixels, 0, false);
3319
3320                                 XplatUI.ScrollWindow (item_control.Handle, pixels, 0, false);
3321                         }
3322                 }
3323
3324                 private void VerticalScroller (object sender, EventArgs e)
3325                 {
3326                         item_control.EndEdit (item_control.edit_item);
3327
3328                         // Avoid unnecessary flickering, when button is
3329                         // kept pressed at the end
3330                         if (v_marker != v_scroll.Value) {
3331                                 int pixels = v_marker - v_scroll.Value;
3332                                 Rectangle area = item_control.ClientRectangle;
3333                                 if (header_control.Visible) {
3334                                         area.Y += header_control.Height;
3335                                         area.Height -= header_control.Height;
3336                                 }
3337
3338                                 v_marker = v_scroll.Value;
3339                                 XplatUI.ScrollWindow (item_control.Handle, area, 0, pixels, false);
3340                         }
3341                 }
3342
3343                 internal override bool IsInputCharInternal (char charCode)
3344                 {
3345                         return true;
3346                 }
3347                 #endregion      // Internal Methods Properties
3348
3349                 #region Protected Methods
3350                 protected override void CreateHandle ()
3351                 {
3352                         base.CreateHandle ();
3353                         is_selection_available = true;
3354                         for (int i = 0; i < SelectedItems.Count; i++)
3355                                 OnSelectedIndexChanged (EventArgs.Empty);
3356                 }
3357
3358                 protected override void Dispose (bool disposing)
3359                 {
3360                         if (disposing) {
3361                                 large_image_list = null;
3362                                 small_image_list = null;
3363                                 state_image_list = null;
3364
3365                                 foreach (ColumnHeader col in columns)
3366                                         col.SetListView (null);
3367
3368                                 if (!virtual_mode) // In virtual mode we don't save the items
3369                                         foreach (ListViewItem item in items)
3370                                                 item.Owner = null;
3371                         }
3372
3373                         base.Dispose (disposing);
3374                 }
3375
3376                 protected override bool IsInputKey (Keys keyData)
3377                 {
3378                         switch (keyData) {
3379                         case Keys.Up:
3380                         case Keys.Down:
3381                         case Keys.PageUp:
3382                         case Keys.PageDown:
3383                         case Keys.Right:
3384                         case Keys.Left:
3385                         case Keys.End:
3386                         case Keys.Home:
3387                                 return true;
3388
3389                         default:
3390                                 break;
3391                         }
3392
3393                         return base.IsInputKey (keyData);
3394                 }
3395
3396                 protected virtual void OnAfterLabelEdit (LabelEditEventArgs e)
3397                 {
3398                         LabelEditEventHandler eh = (LabelEditEventHandler)(Events [AfterLabelEditEvent]);
3399                         if (eh != null)
3400                                 eh (this, e);
3401                 }
3402
3403                 protected override void OnBackgroundImageChanged (EventArgs e)
3404                 {
3405                         item_control.BackgroundImage = BackgroundImage;
3406                         base.OnBackgroundImageChanged (e);
3407                 }
3408
3409                 protected virtual void OnBeforeLabelEdit (LabelEditEventArgs e)
3410                 {
3411                         LabelEditEventHandler eh = (LabelEditEventHandler)(Events [BeforeLabelEditEvent]);
3412                         if (eh != null)
3413                                 eh (this, e);
3414                 }
3415
3416                 protected internal virtual void OnColumnClick (ColumnClickEventArgs e)
3417                 {
3418                         ColumnClickEventHandler eh = (ColumnClickEventHandler)(Events [ColumnClickEvent]);
3419                         if (eh != null)
3420                                 eh (this, e);
3421                 }
3422
3423                 protected internal virtual void OnDrawColumnHeader(DrawListViewColumnHeaderEventArgs e)
3424                 {
3425                         DrawListViewColumnHeaderEventHandler eh = (DrawListViewColumnHeaderEventHandler)(Events[DrawColumnHeaderEvent]);
3426                         if (eh != null)
3427                                 eh(this, e);
3428                 }
3429
3430                 protected internal virtual void OnDrawItem(DrawListViewItemEventArgs e)
3431                 {
3432                         DrawListViewItemEventHandler eh = (DrawListViewItemEventHandler)(Events[DrawItemEvent]);
3433                         if (eh != null)
3434                                 eh(this, e);
3435                 }
3436
3437                 protected internal virtual void OnDrawSubItem(DrawListViewSubItemEventArgs e)
3438                 {
3439                         DrawListViewSubItemEventHandler eh = (DrawListViewSubItemEventHandler)(Events[DrawSubItemEvent]);
3440                         if (eh != null)
3441                                 eh(this, e);
3442                 }
3443
3444                 protected override void OnFontChanged (EventArgs e)
3445                 {
3446                         base.OnFontChanged (e);
3447                         Redraw (true);
3448                 }
3449
3450                 protected override void OnHandleCreated (EventArgs e)
3451                 {
3452                         base.OnHandleCreated (e);
3453                         CalculateListView (alignment);
3454                         if (!virtual_mode) // Sorting is not allowed in virtual mode
3455                                 Sort ();
3456                 }
3457
3458                 protected override void OnHandleDestroyed (EventArgs e)
3459                 {
3460                         base.OnHandleDestroyed (e);
3461                 }
3462
3463                 protected virtual void OnItemActivate (EventArgs e)
3464                 {
3465                         EventHandler eh = (EventHandler)(Events [ItemActivateEvent]);
3466                         if (eh != null)
3467                                 eh (this, e);
3468                 }
3469
3470                 protected internal virtual void OnItemCheck (ItemCheckEventArgs ice)
3471                 {
3472                         ItemCheckEventHandler eh = (ItemCheckEventHandler)(Events [ItemCheckEvent]);
3473                         if (eh != null)
3474                                 eh (this, ice);
3475                 }
3476
3477                 protected internal virtual void OnItemChecked (ItemCheckedEventArgs e)
3478                 {
3479                         ItemCheckedEventHandler eh = (ItemCheckedEventHandler)(Events [ItemCheckedEvent]);
3480                         if (eh != null)
3481                                 eh (this, e);
3482                 }
3483
3484                 protected virtual void OnItemDrag (ItemDragEventArgs e)
3485                 {
3486                         ItemDragEventHandler eh = (ItemDragEventHandler)(Events [ItemDragEvent]);
3487                         if (eh != null)
3488                                 eh (this, e);
3489                 }
3490
3491                 protected virtual void OnItemMouseHover (ListViewItemMouseHoverEventArgs e)
3492                 {
3493                         ListViewItemMouseHoverEventHandler eh = (ListViewItemMouseHoverEventHandler)(Events [ItemMouseHoverEvent]);
3494                         if (eh != null)
3495                                 eh (this, e);
3496                 }
3497
3498                 protected internal virtual void OnItemSelectionChanged (ListViewItemSelectionChangedEventArgs e)
3499                 {
3500                         ListViewItemSelectionChangedEventHandler eh =
3501                                 (ListViewItemSelectionChangedEventHandler) Events [ItemSelectionChangedEvent];
3502                         if (eh != null)
3503                                 eh (this, e);
3504                 }
3505
3506                 protected override void OnMouseHover (EventArgs e)
3507                 {
3508                         base.OnMouseHover (e);
3509                 }
3510
3511                 protected override void OnParentChanged (EventArgs e)
3512                 {
3513                         base.OnParentChanged (e);
3514                 }
3515
3516                 protected virtual void OnSelectedIndexChanged (EventArgs e)
3517                 {
3518                         EventHandler eh = (EventHandler)(Events [SelectedIndexChangedEvent]);
3519                         if (eh != null)
3520                                 eh (this, e);
3521                 }
3522
3523                 protected override void OnSystemColorsChanged (EventArgs e)
3524                 {
3525                         base.OnSystemColorsChanged (e);
3526                 }
3527
3528                 protected internal virtual void OnCacheVirtualItems (CacheVirtualItemsEventArgs e)
3529                 {
3530                         CacheVirtualItemsEventHandler eh = (CacheVirtualItemsEventHandler)Events [CacheVirtualItemsEvent];
3531                         if (eh != null)
3532                                 eh (this, e);
3533                 }
3534
3535                 protected virtual void OnRetrieveVirtualItem (RetrieveVirtualItemEventArgs e)
3536                 {
3537                         RetrieveVirtualItemEventHandler eh = (RetrieveVirtualItemEventHandler)Events [RetrieveVirtualItemEvent];
3538                         if (eh != null)
3539                                 eh (this, e);
3540                 }
3541
3542                 [EditorBrowsable (EditorBrowsableState.Advanced)]
3543                 protected virtual void OnRightToLeftLayoutChanged (EventArgs e)
3544                 {
3545                         EventHandler eh = (EventHandler)Events[RightToLeftLayoutChangedEvent];
3546                         if (eh != null)
3547                                 eh (this, e);
3548                 }
3549
3550                 protected virtual void OnSearchForVirtualItem (SearchForVirtualItemEventArgs e)
3551                 {
3552                         SearchForVirtualItemEventHandler eh = (SearchForVirtualItemEventHandler) Events [SearchForVirtualItemEvent];
3553                         if (eh != null)
3554                                 eh (this, e);
3555                 }
3556
3557                 protected virtual void OnVirtualItemsSelectionRangeChanged (ListViewVirtualItemsSelectionRangeChangedEventArgs e)
3558                 {
3559                         ListViewVirtualItemsSelectionRangeChangedEventHandler eh =
3560                                 (ListViewVirtualItemsSelectionRangeChangedEventHandler) Events [VirtualItemsSelectionRangeChangedEvent];
3561                         if (eh != null)
3562                                 eh (this, e);
3563                 }
3564
3565                 protected void RealizeProperties ()
3566                 {
3567                         // FIXME: TODO
3568                 }
3569
3570                 protected void UpdateExtendedStyles ()
3571                 {
3572                         // FIXME: TODO
3573                 }
3574
3575                 bool refocusing = false;
3576
3577                 protected override void WndProc (ref Message m)
3578                 {
3579                         switch ((Msg)m.Msg) {
3580                         case Msg.WM_KILLFOCUS:
3581                                 Control receiver = Control.FromHandle (m.WParam);
3582                                 if (receiver == item_control) {
3583                                         has_focus = false;
3584                                         refocusing = true;
3585                                         return;
3586                                 }
3587                                 break;
3588                         case Msg.WM_SETFOCUS:
3589                                 if (refocusing) {
3590                                         has_focus = true;
3591                                         refocusing = false;
3592                                         return;
3593                                 }
3594                                 break;
3595                         default:
3596                                 break;
3597                         }
3598                         base.WndProc (ref m);
3599                 }
3600                 #endregion // Protected Methods
3601
3602                 #region Public Instance Methods
3603                 public void ArrangeIcons ()
3604                 {
3605                         ArrangeIcons (this.alignment);
3606                 }
3607
3608                 public void ArrangeIcons (ListViewAlignment value)
3609                 {
3610                         // Icons are arranged only if view is set to LargeIcon or SmallIcon
3611                         if (view == View.LargeIcon || view == View.SmallIcon)
3612                                 Redraw (true);
3613                 }
3614
3615                 public void AutoResizeColumn (int columnIndex, ColumnHeaderAutoResizeStyle headerAutoResize)
3616                 {
3617                         if (columnIndex < 0 || columnIndex >= columns.Count)
3618                                 throw new ArgumentOutOfRangeException ("columnIndex");
3619
3620                         columns [columnIndex].AutoResize (headerAutoResize);
3621                 }
3622
3623                 public void AutoResizeColumns (ColumnHeaderAutoResizeStyle headerAutoResize)
3624                 {
3625                         BeginUpdate ();
3626                         foreach (ColumnHeader col in columns)
3627                                 col.AutoResize (headerAutoResize);
3628                         EndUpdate ();
3629                 }
3630
3631                 public void BeginUpdate ()
3632                 {
3633                         // flag to avoid painting
3634                         updating = true;
3635                 }
3636
3637                 public void Clear ()
3638                 {
3639                         columns.Clear ();
3640                         items.Clear (); // Redraw (true) called here
3641                 }
3642
3643                 public void EndUpdate ()
3644                 {
3645                         // flag to avoid painting
3646                         updating = false;
3647
3648                         // probably, now we need a redraw with recalculations
3649                         this.Redraw (true);
3650                 }
3651
3652                 public void EnsureVisible (int index)
3653                 {
3654                         if (index < 0 || index >= items.Count || scrollable == false || updating)
3655                                 return;
3656
3657                         Rectangle view_rect = item_control.ClientRectangle;
3658                         // Avoid direct access to items in virtual mode, and use item bounds otherwise, since we could have reordered items
3659                         Rectangle bounds = virtual_mode ? new Rectangle (GetItemLocation (index), ItemSize) : items [index].Bounds;
3660
3661                         if (view == View.Details && header_style != ColumnHeaderStyle.None) {
3662                                 view_rect.Y += header_control.Height;
3663                                 view_rect.Height -= header_control.Height;
3664                         }
3665
3666                         if (view_rect.Contains (bounds))
3667                                 return;
3668
3669                         if (View != View.Details) {
3670                                 if (bounds.Left < 0)
3671                                         h_scroll.Value += bounds.Left;
3672                                 // Don't shift right unless right-to-left layout is active. (Xamarin bug 22483)
3673                                 else if (this.RightToLeftLayout && bounds.Right > view_rect.Right)
3674                                         h_scroll.Value += (bounds.Right - view_rect.Right);
3675                         }
3676
3677                         if (bounds.Top < view_rect.Y)
3678                                 v_scroll.Value += bounds.Top - view_rect.Y;
3679                         else if (bounds.Bottom > view_rect.Bottom)
3680                                 v_scroll.Value += (bounds.Bottom - view_rect.Bottom);
3681                 }
3682
3683                 public ListViewItem FindItemWithText (string text)
3684                 {
3685                         if (items.Count == 0)
3686                                 return null;
3687
3688                         return FindItemWithText (text, true, 0, true);
3689                 }
3690
3691                 public ListViewItem FindItemWithText (string text, bool includeSubItemsInSearch, int startIndex)
3692                 {
3693                         return FindItemWithText (text, includeSubItemsInSearch, startIndex, true, false);
3694                 }
3695
3696                 public ListViewItem FindItemWithText (string text, bool includeSubItemsInSearch, int startIndex, bool isPrefixSearch)
3697                 {
3698                         return FindItemWithText (text, includeSubItemsInSearch, startIndex, isPrefixSearch, false);
3699                 }
3700
3701                 internal ListViewItem FindItemWithText (string text, bool includeSubItemsInSearch, int startIndex, bool isPrefixSearch, bool roundtrip)
3702                 {
3703                         if (startIndex < 0 || startIndex >= items.Count)
3704                                 throw new ArgumentOutOfRangeException ("startIndex");
3705
3706                         if (text == null)
3707                                 throw new ArgumentNullException ("text");
3708
3709                         if (virtual_mode) {
3710                                 SearchForVirtualItemEventArgs args = new SearchForVirtualItemEventArgs (true,
3711                                                 isPrefixSearch, includeSubItemsInSearch, text, Point.Empty,
3712                                                 SearchDirectionHint.Down, startIndex);
3713
3714                                 OnSearchForVirtualItem (args);
3715                                 int idx = args.Index;
3716                                 if (idx >= 0 && idx < virtual_list_size)
3717                                         return items [idx];
3718
3719                                 return null;
3720                         }
3721
3722                         int i = startIndex;
3723                         while (true) {
3724                                 ListViewItem lvi = items [i];
3725
3726                                 if (isPrefixSearch) { // prefix search
3727                                         if (CultureInfo.CurrentCulture.CompareInfo.IsPrefix (lvi.Text, text, CompareOptions.IgnoreCase))
3728                                                 return lvi;
3729                                 } else if (String.Compare (lvi.Text, text, true) == 0) // match
3730                                         return lvi;
3731
3732                                 if (i + 1 >= items.Count) {
3733                                         if (!roundtrip)
3734                                                 break;
3735
3736                                         i = 0;
3737                                 } else
3738                                         i++;
3739
3740                                 if (i == startIndex)
3741                                         break;
3742                         }
3743
3744                         // Subitems have a minor priority, so we have to do a second linear search
3745                         // Also, we don't need to to a roundtrip search for them by now
3746                         if (includeSubItemsInSearch) {
3747                                 for (i = startIndex; i < items.Count; i++) {
3748                                         ListViewItem lvi = items [i];
3749                                         foreach (ListViewItem.ListViewSubItem sub_item in lvi.SubItems)
3750                                                 if (isPrefixSearch) {
3751                                                         if (CultureInfo.CurrentCulture.CompareInfo.IsPrefix (sub_item.Text,
3752                                                                 text, CompareOptions.IgnoreCase))
3753                                                                 return lvi;
3754                                                 } else if (String.Compare (sub_item.Text, text, true) == 0)
3755                                                         return lvi;
3756                                 }
3757                         }
3758
3759                         return null;
3760                 }
3761
3762                 public ListViewItem FindNearestItem (SearchDirectionHint searchDirection, int x, int y)
3763                 {
3764                         return FindNearestItem (searchDirection, new Point (x, y));
3765                 }
3766
3767                 public ListViewItem FindNearestItem (SearchDirectionHint dir, Point point)
3768                 {
3769                         if (dir < SearchDirectionHint.Left || dir > SearchDirectionHint.Down)
3770                                 throw new ArgumentOutOfRangeException ("searchDirection");
3771
3772                         if (view != View.LargeIcon && view != View.SmallIcon)
3773                                 throw new InvalidOperationException ();
3774
3775                         if (virtual_mode) {
3776                                 SearchForVirtualItemEventArgs args = new SearchForVirtualItemEventArgs (false,
3777                                                 false, false, String.Empty, point,
3778                                                 dir, 0);
3779
3780                                 OnSearchForVirtualItem (args);
3781                                 int idx = args.Index;
3782                                 if (idx >= 0 && idx < virtual_list_size)
3783                                         return items [idx];
3784
3785                                 return null;
3786                         }
3787
3788                         ListViewItem item = null;
3789                         int min_dist = Int32.MaxValue;
3790
3791                         //
3792                         // It looks like .Net does a previous adjustment
3793                         //
3794                         switch (dir) {
3795                                 case SearchDirectionHint.Up:
3796                                         point.Y -= item_size.Height;
3797                                         break;
3798                                 case SearchDirectionHint.Down:
3799                                         point.Y += item_size.Height;
3800                                         break;
3801                                 case SearchDirectionHint.Left:
3802                                         point.X -= item_size.Width;
3803                                         break;
3804                                 case SearchDirectionHint.Right:
3805                                         point.X += item_size.Width;
3806                                         break;
3807                         }
3808
3809                         for (int i = 0; i < items.Count; i++) {
3810                                 Point item_loc = GetItemLocation (i);
3811
3812                                 if (dir == SearchDirectionHint.Up) {
3813                                         if (point.Y < item_loc.Y)
3814                                                 continue;
3815                                 } else if (dir == SearchDirectionHint.Down) {
3816                                         if (point.Y > item_loc.Y)
3817                                                 continue;
3818                                 } else if (dir == SearchDirectionHint.Left) {
3819                                         if (point.X < item_loc.X)
3820                                                 continue;
3821                                 } else if (dir == SearchDirectionHint.Right) {
3822                                         if (point.X > item_loc.X)
3823                                                 continue;
3824                                 }
3825
3826                                 int x_dist = point.X - item_loc.X;
3827                                 int y_dist = point.Y - item_loc.Y;
3828
3829                                 int dist = x_dist * x_dist  + y_dist * y_dist;
3830                                 if (dist < min_dist) {
3831                                         item = items [i];
3832                                         min_dist = dist;
3833                                 }
3834                         }
3835
3836                         return item;
3837                 }
3838
3839                 public ListViewItem GetItemAt (int x, int y)
3840                 {
3841                         Size item_size = ItemSize;
3842                         for (int i = 0; i < items.Count; i++) {
3843                                 Rectangle item_rect = items [i].Bounds;
3844                                 if (item_rect.Contains (x, y))
3845                                         return items [i];
3846                         }
3847
3848                         return null;
3849                 }
3850
3851                 public Rectangle GetItemRect (int index)
3852                 {
3853                         return GetItemRect (index, ItemBoundsPortion.Entire);
3854                 }
3855
3856                 public Rectangle GetItemRect (int index, ItemBoundsPortion portion)
3857                 {
3858                         if (index < 0 || index >= items.Count)
3859                                 throw new IndexOutOfRangeException ("index");
3860
3861                         return items [index].GetBounds (portion);
3862                 }
3863
3864                 public ListViewHitTestInfo HitTest (Point point)
3865                 {
3866                         return HitTest (point.X, point.Y);
3867                 }
3868
3869                 public ListViewHitTestInfo HitTest (int x, int y)
3870                 {
3871                         if (x < 0)
3872                                 throw new ArgumentOutOfRangeException ("x");
3873                         if (y < 0)
3874                                 throw new ArgumentOutOfRangeException ("y");
3875
3876                         ListViewItem item = GetItemAt (x, y);
3877                         if (item == null)
3878                                 return new ListViewHitTestInfo (null, null, ListViewHitTestLocations.None);
3879
3880                         ListViewHitTestLocations locations = 0;
3881                         if (item.GetBounds (ItemBoundsPortion.Label).Contains (x, y))
3882                                 locations |= ListViewHitTestLocations.Label;
3883                         else if (item.GetBounds (ItemBoundsPortion.Icon).Contains (x, y))
3884                                 locations |= ListViewHitTestLocations.Image;
3885                         else if (item.CheckRectReal.Contains (x, y))
3886                                 locations |= ListViewHitTestLocations.StateImage;
3887
3888                         ListViewItem.ListViewSubItem subitem = null;
3889                         if (view == View.Details)
3890                                 foreach (ListViewItem.ListViewSubItem si in item.SubItems)
3891                                         if (si.Bounds.Contains (x, y)) {
3892                                                 subitem = si;
3893                                                 break;
3894                                         }
3895
3896                         return new ListViewHitTestInfo (item, subitem, locations);
3897                 }
3898
3899                 [EditorBrowsable (EditorBrowsableState.Advanced)]
3900                 public void RedrawItems (int startIndex, int endIndex, bool invalidateOnly)
3901                 {
3902                         if (startIndex < 0 || startIndex >= items.Count)
3903                                 throw new ArgumentOutOfRangeException ("startIndex");
3904                         if (endIndex < 0 || endIndex >= items.Count)
3905                                 throw new ArgumentOutOfRangeException ("endIndex");
3906                         if (startIndex > endIndex)
3907                                 throw new ArgumentException ("startIndex");
3908
3909                         if (updating)
3910                                 return;
3911
3912                         for (int i = startIndex; i <= endIndex; i++)
3913                                 items [i].Invalidate ();
3914
3915                         if (!invalidateOnly)
3916                                 Update ();
3917                 }
3918
3919                 public void Sort ()
3920                 {
3921                         if (virtual_mode)
3922                                 throw new InvalidOperationException ();
3923
3924                         Sort (true);
3925                 }
3926
3927                 // we need this overload to reuse the logic for sorting, while allowing
3928                 // redrawing to be done by caller or have it done by this method when
3929                 // sorting is really performed
3930                 //
3931                 // ListViewItemCollection's Add and AddRange methods call this overload
3932                 // with redraw set to false, as they take care of redrawing themselves
3933                 // (they even want to redraw the listview if no sort is performed, as
3934                 // an item was added), while ListView.Sort () only wants to redraw if
3935                 // sorting was actually performed
3936                 private void Sort (bool redraw)
3937                 {
3938                         if (!IsHandleCreated || item_sorter == null) {
3939                                 return;
3940                         }
3941
3942                         items.Sort (item_sorter);
3943                         if (redraw)
3944                                 this.Redraw (true);
3945                 }
3946
3947                 public override string ToString ()
3948                 {
3949                         int count = this.Items.Count;
3950
3951                         if (count == 0)
3952                                 return string.Format ("System.Windows.Forms.ListView, Items.Count: 0");
3953                         else
3954                                 return string.Format ("System.Windows.Forms.ListView, Items.Count: {0}, Items[0]: {1}", count, this.Items [0].ToString ());
3955                 }
3956                 #endregion      // Public Instance Methods
3957
3958
3959                 #region Subclasses
3960
3961                 internal class HeaderControl : Control {
3962
3963                         ListView owner;
3964                         bool column_resize_active = false;
3965                         ColumnHeader resize_column;
3966                         ColumnHeader clicked_column;
3967                         ColumnHeader drag_column;
3968                         int drag_x;
3969                         int drag_to_index = -1;
3970                         ColumnHeader entered_column_header;
3971
3972                         public HeaderControl (ListView owner)
3973                         {
3974                                 this.owner = owner;
3975                                 this.SetStyle (ControlStyles.DoubleBuffer, true);
3976                                 MouseDown += new MouseEventHandler (HeaderMouseDown);
3977                                 MouseMove += new MouseEventHandler (HeaderMouseMove);
3978                                 MouseUp += new MouseEventHandler (HeaderMouseUp);
3979                                 MouseLeave += new EventHandler (OnMouseLeave);
3980                         }
3981
3982                         internal ColumnHeader EnteredColumnHeader {
3983                                 get { return entered_column_header; }
3984                                 private set {
3985                                         if (entered_column_header == value)
3986                                                 return;
3987                                         if (ThemeEngine.Current.ListViewHasHotHeaderStyle) {
3988                                                 Region region_to_invalidate = new Region ();
3989                                                 region_to_invalidate.MakeEmpty ();
3990                                                 if (entered_column_header != null)
3991                                                         region_to_invalidate.Union (GetColumnHeaderInvalidateArea (entered_column_header));
3992                                                 entered_column_header = value;
3993                                                 if (entered_column_header != null)
3994                                                         region_to_invalidate.Union (GetColumnHeaderInvalidateArea (entered_column_header));
3995                                                 Invalidate (region_to_invalidate);
3996                                                 region_to_invalidate.Dispose ();
3997                                         } else
3998                                                 entered_column_header = value;
3999                                 }
4000                         }
4001
4002                         void OnMouseLeave (object sender, EventArgs e)
4003                         {
4004                                 EnteredColumnHeader = null;
4005                         }
4006
4007                         private ColumnHeader ColumnAtX (int x)
4008                         {
4009                                 Point pt = new Point (x, 0);
4010                                 ColumnHeader result = null;
4011                                 foreach (ColumnHeader col in owner.Columns) {
4012                                         if (col.Rect.Contains (pt)) {
4013                                                 result = col;
4014                                                 break;
4015                                         }
4016                                 }
4017                                 return result;
4018                         }
4019
4020                         private int GetReorderedIndex (ColumnHeader col)
4021                         {
4022                                 if (owner.reordered_column_indices == null)
4023                                         return col.Index;
4024                                 else
4025                                         for (int i = 0; i < owner.Columns.Count; i++)
4026                                                 if (owner.reordered_column_indices [i] == col.Index)
4027                                                         return i;
4028                                 throw new Exception ("Column index missing from reordered array");
4029                         }
4030
4031                         private void HeaderMouseDown (object sender, MouseEventArgs me)
4032                         {
4033                                 if (resize_column != null) {
4034                                         column_resize_active = true;
4035                                         Capture = true;
4036                                         return;
4037                                 }
4038
4039                                 clicked_column = ColumnAtX (me.X + owner.h_marker);
4040
4041                                 if (clicked_column != null) {
4042                                         Capture = true;
4043                                         if (owner.AllowColumnReorder) {
4044                                                 drag_x = me.X;
4045                                                 drag_column = (ColumnHeader) (clicked_column as ICloneable).Clone ();
4046                                                 drag_column.Rect = clicked_column.Rect;
4047                                                 drag_to_index = GetReorderedIndex (clicked_column);
4048                                         }
4049                                         clicked_column.Pressed = true;
4050                                         Invalidate (clicked_column);
4051                                         return;
4052                                 }
4053                         }
4054
4055                         void Invalidate (ColumnHeader columnHeader)
4056                         {
4057                                 Invalidate (GetColumnHeaderInvalidateArea (columnHeader));
4058                         }
4059
4060                         Rectangle GetColumnHeaderInvalidateArea (ColumnHeader columnHeader)
4061                         {
4062                                 Rectangle bounds = columnHeader.Rect;
4063                                 bounds.X -= owner.h_marker;
4064                                 return bounds;
4065                         }
4066
4067                         void StopResize ()
4068                         {
4069                                 column_resize_active = false;
4070                                 resize_column = null;
4071                                 Capture = false;
4072                                 Cursor = Cursors.Default;
4073                         }
4074
4075                         private void HeaderMouseMove (object sender, MouseEventArgs me)
4076                         {
4077                                 Point pt = new Point (me.X + owner.h_marker, me.Y);
4078
4079                                 if (column_resize_active) {
4080                                         int width = pt.X - resize_column.X;
4081                                         if (width < 0)
4082                                                 width = 0;
4083
4084                                         if (!owner.CanProceedWithResize (resize_column, width)){
4085                                                 StopResize ();
4086                                                 return;
4087                                         }
4088                                         resize_column.Width = width;
4089                                         return;
4090                                 }
4091
4092                                 resize_column = null;
4093
4094                                 if (clicked_column != null) {
4095                                         if (owner.AllowColumnReorder) {
4096                                                 Rectangle r;
4097
4098                                                 r = drag_column.Rect;
4099                                                 r.X = clicked_column.Rect.X + me.X - drag_x;
4100                                                 drag_column.Rect = r;
4101
4102                                                 int x = me.X + owner.h_marker;
4103                                                 ColumnHeader over = ColumnAtX (x);
4104                                                 if (over == null)
4105                                                         drag_to_index = owner.Columns.Count;
4106                                                 else if (x < over.X + over.Width / 2)
4107                                                         drag_to_index = GetReorderedIndex (over);
4108                                                 else
4109                                                         drag_to_index = GetReorderedIndex (over) + 1;
4110                                                 Invalidate ();
4111                                         } else {
4112                                                 ColumnHeader over = ColumnAtX (me.X + owner.h_marker);
4113                                                 bool pressed = clicked_column.Pressed;
4114                                                 clicked_column.Pressed = over == clicked_column;
4115                                                 if (clicked_column.Pressed ^ pressed)
4116                                                         Invalidate (clicked_column);
4117                                         }
4118                                         return;
4119                                 }
4120
4121                                 for (int i = 0; i < owner.Columns.Count; i++) {
4122                                         Rectangle zone = owner.Columns [i].Rect;
4123                                         if (zone.Contains (pt))
4124                                                 EnteredColumnHeader = owner.Columns [i];
4125                                         zone.X = zone.Right - 5;
4126                                         zone.Width = 10;
4127                                         if (zone.Contains (pt)) {
4128                                                 if (i < owner.Columns.Count - 1 && owner.Columns [i + 1].Width == 0)
4129                                                         i++;
4130                                                 resize_column = owner.Columns [i];
4131                                                 break;
4132                                         }
4133                                 }
4134
4135                                 if (resize_column == null)
4136                                         Cursor = Cursors.Default;
4137                                 else
4138                                         Cursor = Cursors.VSplit;
4139                         }
4140
4141                         void HeaderMouseUp (object sender, MouseEventArgs me)
4142                         {
4143                                 Capture = false;
4144
4145                                 if (column_resize_active) {
4146                                         int column_idx = resize_column.Index;
4147                                         StopResize ();
4148                                         owner.RaiseColumnWidthChanged (column_idx);
4149                                         return;
4150                                 }
4151
4152                                 if (clicked_column != null && clicked_column.Pressed) {
4153                                         clicked_column.Pressed = false;
4154                                         Invalidate (clicked_column);
4155                                         owner.OnColumnClick (new ColumnClickEventArgs (clicked_column.Index));
4156                                 }
4157
4158                                 if (drag_column != null && owner.AllowColumnReorder) {
4159                                         drag_column = null;
4160                                         if (drag_to_index > GetReorderedIndex (clicked_column))
4161                                                 drag_to_index--;
4162                                         if (owner.GetReorderedColumn (drag_to_index) != clicked_column)
4163                                                 owner.ReorderColumn (clicked_column, drag_to_index, true);
4164                                         drag_to_index = -1;
4165                                         Invalidate ();
4166                                 }
4167
4168                                 clicked_column = null;
4169                         }
4170
4171                         internal override void OnPaintInternal (PaintEventArgs pe)
4172                         {
4173                                 if (owner.updating)
4174                                         return;
4175
4176                                 Theme theme = ThemeEngine.Current;
4177                                 theme.DrawListViewHeader (pe.Graphics, pe.ClipRectangle, this.owner);
4178
4179                                 if (drag_column == null)
4180                                         return;
4181
4182                                 int target_x;
4183                                 if (drag_to_index == owner.Columns.Count)
4184                                         target_x = owner.GetReorderedColumn (drag_to_index - 1).Rect.Right - owner.h_marker;
4185                                 else
4186                                         target_x = owner.GetReorderedColumn (drag_to_index).Rect.X - owner.h_marker;
4187                                 theme.DrawListViewHeaderDragDetails (pe.Graphics, owner, drag_column, target_x);
4188                         }
4189
4190                         protected override void WndProc (ref Message m)
4191                         {
4192                                 switch ((Msg)m.Msg) {
4193                                 case Msg.WM_SETFOCUS:
4194                                         owner.Focus ();
4195                                         break;
4196                                 default:
4197                                         base.WndProc (ref m);
4198                                         break;
4199                                 }
4200                         }
4201                 }
4202
4203                 private class ItemComparer : IComparer {
4204                         readonly SortOrder sort_order;
4205
4206                         public ItemComparer (SortOrder sortOrder)
4207                         {
4208                                 sort_order = sortOrder;
4209                         }
4210
4211                         public int Compare (object x, object y)
4212                         {
4213                                 ListViewItem item_x = x as ListViewItem;
4214                                 ListViewItem item_y = y as ListViewItem;
4215                                 if (sort_order == SortOrder.Ascending)
4216                                         return String.Compare (item_x.Text, item_y.Text);
4217                                 else
4218                                         return String.Compare (item_y.Text, item_x.Text);
4219                         }
4220                 }
4221
4222                 [ListBindable (false)]
4223                 public class CheckedIndexCollection : IList, ICollection, IEnumerable
4224                 {
4225                         private readonly ListView owner;
4226
4227                         #region Public Constructor
4228                         public CheckedIndexCollection (ListView owner)
4229                         {
4230                                 this.owner = owner;
4231                         }
4232                         #endregion      // Public Constructor
4233
4234                         #region Public Properties
4235                         [Browsable (false)]
4236                         public int Count {
4237                                 get { return owner.CheckedItems.Count; }
4238                         }
4239
4240                         public bool IsReadOnly {
4241                                 get { return true; }
4242                         }
4243
4244                         public int this [int index] {
4245                                 get {
4246                                         int [] indices = GetIndices ();
4247                                         if (index < 0 || index >= indices.Length)
4248                                                 throw new ArgumentOutOfRangeException ("index");
4249                                         return indices [index];
4250                                 }
4251                         }
4252
4253                         bool ICollection.IsSynchronized {
4254                                 get { return false; }
4255                         }
4256
4257                         object ICollection.SyncRoot {
4258                                 get { return this; }
4259                         }
4260
4261                         bool IList.IsFixedSize {
4262                                 get { return true; }
4263                         }
4264
4265                         object IList.this [int index] {
4266                                 get { return this [index]; }
4267                                 set { throw new NotSupportedException ("SetItem operation is not supported."); }
4268                         }
4269                         #endregion      // Public Properties
4270
4271                         #region Public Methods
4272                         public bool Contains (int checkedIndex)
4273                         {
4274                                 int [] indices = GetIndices ();
4275                                 for (int i = 0; i < indices.Length; i++) {
4276                                         if (indices [i] == checkedIndex)
4277                                                 return true;
4278                                 }
4279                                 return false;
4280                         }
4281
4282                         public IEnumerator GetEnumerator ()
4283                         {
4284                                 int [] indices = GetIndices ();
4285                                 return indices.GetEnumerator ();
4286                         }
4287
4288                         void ICollection.CopyTo (Array dest, int index)
4289                         {
4290                                 int [] indices = GetIndices ();
4291                                 Array.Copy (indices, 0, dest, index, indices.Length);
4292                         }
4293
4294                         int IList.Add (object value)
4295                         {
4296                                 throw new NotSupportedException ("Add operation is not supported.");
4297                         }
4298
4299                         void IList.Clear ()
4300                         {
4301                                 throw new NotSupportedException ("Clear operation is not supported.");
4302                         }
4303
4304                         bool IList.Contains (object checkedIndex)
4305                         {
4306                                 if (!(checkedIndex is int))
4307                                         return false;
4308                                 return Contains ((int) checkedIndex);
4309                         }
4310
4311                         int IList.IndexOf (object checkedIndex)
4312                         {
4313                                 if (!(checkedIndex is int))
4314                                         return -1;
4315                                 return IndexOf ((int) checkedIndex);
4316                         }
4317
4318                         void IList.Insert (int index, object value)
4319                         {
4320                                 throw new NotSupportedException ("Insert operation is not supported.");
4321                         }
4322
4323                         void IList.Remove (object value)
4324                         {
4325                                 throw new NotSupportedException ("Remove operation is not supported.");
4326                         }
4327
4328                         void IList.RemoveAt (int index)
4329                         {
4330                                 throw new NotSupportedException ("RemoveAt operation is not supported.");
4331                         }
4332
4333                         public int IndexOf (int checkedIndex)
4334                         {
4335                                 int [] indices = GetIndices ();
4336                                 for (int i = 0; i < indices.Length; i++) {
4337                                         if (indices [i] == checkedIndex)
4338                                                 return i;
4339                                 }
4340                                 return -1;
4341                         }
4342                         #endregion      // Public Methods
4343
4344                         private int [] GetIndices ()
4345                         {
4346                                 ArrayList checked_items = owner.CheckedItems.List;
4347                                 int [] indices = new int [checked_items.Count];
4348                                 for (int i = 0; i < checked_items.Count; i++) {
4349                                         ListViewItem item = (ListViewItem) checked_items [i];
4350                                         indices [i] = item.Index;
4351                                 }
4352                                 return indices;
4353                         }
4354                 }       // CheckedIndexCollection
4355
4356                 [ListBindable (false)]
4357                 public class CheckedListViewItemCollection : IList, ICollection, IEnumerable
4358                 {
4359                         private readonly ListView owner;
4360                         private ArrayList list;
4361
4362                         #region Public Constructor
4363                         public CheckedListViewItemCollection (ListView owner)
4364                         {
4365                                 this.owner = owner;
4366                                 this.owner.Items.Changed += new CollectionChangedHandler (
4367                                         ItemsCollection_Changed);
4368                         }
4369                         #endregion      // Public Constructor
4370
4371                         #region Public Properties
4372                         [Browsable (false)]
4373                         public int Count {
4374                                 get {
4375                                         if (!owner.CheckBoxes)
4376                                                 return 0;
4377                                         return List.Count;
4378                                 }
4379                         }
4380
4381                         public bool IsReadOnly {
4382                                 get { return true; }
4383                         }
4384
4385                         public ListViewItem this [int index] {
4386                                 get {
4387                                         if (owner.VirtualMode)
4388                                                 throw new InvalidOperationException ();
4389                                         ArrayList checked_items = List;
4390                                         if (index < 0 || index >= checked_items.Count)
4391                                                 throw new ArgumentOutOfRangeException ("index");
4392                                         return (ListViewItem) checked_items [index];
4393                                 }
4394                         }
4395
4396                         public virtual ListViewItem this [string key] {
4397                                 get {
4398                                         int idx = IndexOfKey (key);
4399                                         return idx == -1 ? null : (ListViewItem) List [idx];
4400                                 }
4401                         }
4402
4403                         bool ICollection.IsSynchronized {
4404                                 get { return false; }
4405                         }
4406
4407                         object ICollection.SyncRoot {
4408                                 get { return this; }
4409                         }
4410
4411                         bool IList.IsFixedSize {
4412                                 get { return true; }
4413                         }
4414
4415                         object IList.this [int index] {
4416                                 get { return this [index]; }
4417                                 set { throw new NotSupportedException ("SetItem operation is not supported."); }
4418                         }
4419                         #endregion      // Public Properties
4420
4421                         #region Public Methods
4422                         public bool Contains (ListViewItem item)
4423                         {
4424                                 if (!owner.CheckBoxes)
4425                                         return false;
4426                                 return List.Contains (item);
4427                         }
4428
4429                         public virtual bool ContainsKey (string key)
4430                         {
4431                                 return IndexOfKey (key) != -1;
4432                         }
4433
4434                         public void CopyTo (Array dest, int index)
4435                         {
4436                                 if (owner.VirtualMode)
4437                                         throw new InvalidOperationException ();
4438                                 if (!owner.CheckBoxes)
4439                                         return;
4440                                 List.CopyTo (dest, index);
4441                         }
4442
4443                         public IEnumerator GetEnumerator ()
4444                         {
4445                                 if (owner.VirtualMode)
4446                                         throw new InvalidOperationException ();
4447                                 if (!owner.CheckBoxes)
4448                                         return (new ListViewItem [0]).GetEnumerator ();
4449                                 return List.GetEnumerator ();
4450                         }
4451
4452                         int IList.Add (object value)
4453                         {
4454                                 throw new NotSupportedException ("Add operation is not supported.");
4455                         }
4456
4457                         void IList.Clear ()
4458                         {
4459                                 throw new NotSupportedException ("Clear operation is not supported.");
4460                         }
4461
4462                         bool IList.Contains (object item)
4463                         {
4464                                 if (!(item is ListViewItem))
4465                                         return false;
4466                                 return Contains ((ListViewItem) item);
4467                         }
4468
4469                         int IList.IndexOf (object item)
4470                         {
4471                                 if (!(item is ListViewItem))
4472                                         return -1;
4473                                 return IndexOf ((ListViewItem) item);
4474                         }
4475
4476                         void IList.Insert (int index, object value)
4477                         {
4478                                 throw new NotSupportedException ("Insert operation is not supported.");
4479                         }
4480
4481                         void IList.Remove (object value)
4482                         {
4483                                 throw new NotSupportedException ("Remove operation is not supported.");
4484                         }
4485
4486                         void IList.RemoveAt (int index)
4487                         {
4488                                 throw new NotSupportedException ("RemoveAt operation is not supported.");
4489                         }
4490
4491                         public int IndexOf (ListViewItem item)
4492                         {
4493                                 if (owner.VirtualMode)
4494                                         throw new InvalidOperationException ();
4495                                 if (!owner.CheckBoxes)
4496                                         return -1;
4497                                 return List.IndexOf (item);
4498                         }
4499
4500                         public virtual int IndexOfKey (string key)
4501                         {
4502                                 if (owner.VirtualMode)
4503                                         throw new InvalidOperationException ();
4504                                 if (key == null || key.Length == 0)
4505                                         return -1;
4506
4507                                 ArrayList checked_items = List;
4508                                 for (int i = 0; i < checked_items.Count; i++) {
4509                                         ListViewItem item = (ListViewItem) checked_items [i];
4510                                         if (String.Compare (key, item.Name, true) == 0)
4511                                                 return i;
4512                                 }
4513
4514                                 return -1;
4515                         }
4516                         #endregion      // Public Methods
4517
4518                         internal ArrayList List {
4519                                 get {
4520                                         if (list == null) {
4521                                                 list = new ArrayList ();
4522                                                 foreach (ListViewItem item in owner.Items) {
4523                                                         if (item.Checked)
4524                                                                 list.Add (item);
4525                                                 }
4526                                         }
4527                                         return list;
4528                                 }
4529                         }
4530
4531                         internal void Reset ()
4532                         {
4533                                 // force re-population of list
4534                                 list = null;
4535                         }
4536
4537                         private void ItemsCollection_Changed ()
4538                         {
4539                                 Reset ();
4540                         }
4541                 }       // CheckedListViewItemCollection
4542
4543                 [ListBindable (false)]
4544                 public class ColumnHeaderCollection : IList, ICollection, IEnumerable
4545                 {
4546                         internal ArrayList list;
4547                         private ListView owner;
4548
4549                         #region UIA Framework Events
4550                         //NOTE:
4551                         //      We are using Reflection to add/remove internal events.
4552                         //      Class ListViewProvider uses the events when View is Details.
4553                         //
4554                         //Event used to generate UIA StructureChangedEvent
4555                         static object UIACollectionChangedEvent = new object ();
4556
4557                         internal event CollectionChangeEventHandler UIACollectionChanged {
4558                                 add {
4559                                         if (owner != null)
4560                                                 owner.Events.AddHandler (UIACollectionChangedEvent, value);
4561                                 }
4562                                 remove {
4563                                         if (owner != null)
4564                                                 owner.Events.RemoveHandler (UIACollectionChangedEvent, value);
4565                                 }
4566                         }
4567
4568                         internal void OnUIACollectionChangedEvent (CollectionChangeEventArgs args)
4569                         {
4570                                 if (owner == null)
4571                                         return;
4572
4573                                 CollectionChangeEventHandler eh
4574                                         = (CollectionChangeEventHandler) owner.Events [UIACollectionChangedEvent];
4575                                 if (eh != null)
4576                                         eh (owner, args);
4577                         }
4578
4579                         #endregion UIA Framework Events
4580
4581                         #region Public Constructor
4582                         public ColumnHeaderCollection (ListView owner)
4583                         {
4584                                 list = new ArrayList ();
4585                                 this.owner = owner;
4586                         }
4587                         #endregion      // Public Constructor
4588
4589                         #region Public Properties
4590                         [Browsable (false)]
4591                         public int Count {
4592                                 get { return list.Count; }
4593                         }
4594
4595                         public bool IsReadOnly {
4596                                 get { return false; }
4597                         }
4598
4599                         public virtual ColumnHeader this [int index] {
4600                                 get {
4601                                         if (index < 0 || index >= list.Count)
4602                                                 throw new ArgumentOutOfRangeException ("index");
4603                                         return (ColumnHeader) list [index];
4604                                 }
4605                         }
4606
4607                         public virtual ColumnHeader this [string key] {
4608                                 get {
4609                                         int idx = IndexOfKey (key);
4610                                         if (idx == -1)
4611                                                 return null;
4612
4613                                         return (ColumnHeader) list [idx];
4614                                 }
4615                         }
4616
4617                         bool ICollection.IsSynchronized {
4618                                 get { return true; }
4619                         }
4620
4621                         object ICollection.SyncRoot {
4622                                 get { return this; }
4623                         }
4624
4625                         bool IList.IsFixedSize {
4626                                 get { return list.IsFixedSize; }
4627                         }
4628
4629                         object IList.this [int index] {
4630                                 get { return this [index]; }
4631                                 set { throw new NotSupportedException ("SetItem operation is not supported."); }
4632                         }
4633                         #endregion      // Public Properties
4634
4635                         #region Public Methods
4636                         public virtual int Add (ColumnHeader value)
4637                         {
4638                                 int idx = list.Add (value);
4639                                 owner.AddColumn (value, idx, true);
4640
4641                                 //UIA Framework event: Item Added
4642                                 OnUIACollectionChangedEvent (new CollectionChangeEventArgs (CollectionChangeAction.Add, value));
4643
4644                                 return idx;
4645                         }
4646
4647                         public virtual ColumnHeader Add (string text, int width, HorizontalAlignment textAlign)
4648                         {
4649                                 string str = text;
4650                                 ColumnHeader colHeader = new ColumnHeader (this.owner, str, textAlign, width);
4651                                 this.Add (colHeader);
4652                                 return colHeader;
4653                         }
4654
4655                         public virtual ColumnHeader Add (string text)
4656                         {
4657                                 return Add (String.Empty, text);
4658                         }
4659
4660                         public virtual ColumnHeader Add (string text, int width)
4661                         {
4662                                 return Add (String.Empty, text, width);
4663                         }
4664
4665                         public virtual ColumnHeader Add (string key, string text)
4666                         {
4667                                 ColumnHeader colHeader = new ColumnHeader ();
4668                                 colHeader.Name = key;
4669                                 colHeader.Text = text;
4670                                 Add (colHeader);
4671                                 return colHeader;
4672                         }
4673
4674                         public virtual ColumnHeader Add (string key, string text, int width)
4675                         {
4676                                 return Add (key, text, width, HorizontalAlignment.Left, -1);
4677                         }
4678
4679                         public virtual ColumnHeader Add (string key, string text, int width, HorizontalAlignment textAlign, int imageIndex)
4680                         {
4681                                 ColumnHeader colHeader = new ColumnHeader (key, text, width, textAlign);
4682                                 colHeader.ImageIndex = imageIndex;
4683                                 Add (colHeader);
4684                                 return colHeader;
4685                         }
4686
4687                         public virtual ColumnHeader Add (string key, string text, int width, HorizontalAlignment textAlign, string imageKey)
4688                         {
4689                                 ColumnHeader colHeader = new ColumnHeader (key, text, width, textAlign);
4690                                 colHeader.ImageKey = imageKey;
4691                                 Add (colHeader);
4692                                 return colHeader;
4693                         }
4694
4695                         public virtual void AddRange (ColumnHeader [] values)
4696                         {
4697                                 foreach (ColumnHeader colHeader in values) {
4698                                         int idx = list.Add (colHeader);
4699                                         owner.AddColumn (colHeader, idx, false);
4700                                 }
4701
4702                                 owner.Redraw (true);
4703                         }
4704
4705                         public virtual void Clear ()
4706                         {
4707                                 foreach (ColumnHeader col in list)
4708                                         col.SetListView (null);
4709                                 list.Clear ();
4710                                 owner.ReorderColumns (new int [0], true);
4711
4712                                 //UIA Framework event: Items cleared
4713                                 OnUIACollectionChangedEvent (new CollectionChangeEventArgs (CollectionChangeAction.Refresh, null));
4714
4715                         }
4716
4717                         public bool Contains (ColumnHeader value)
4718                         {
4719                                 return list.Contains (value);
4720                         }
4721
4722                         public virtual bool ContainsKey (string key)
4723                         {
4724                                 return IndexOfKey (key) != -1;
4725                         }
4726
4727                         public IEnumerator GetEnumerator ()
4728                         {
4729                                 return list.GetEnumerator ();
4730                         }
4731
4732                         void ICollection.CopyTo (Array dest, int index)
4733                         {
4734                                 list.CopyTo (dest, index);
4735                         }
4736
4737                         int IList.Add (object value)
4738                         {
4739                                 if (! (value is ColumnHeader)) {
4740                                         throw new ArgumentException ("Not of type ColumnHeader", "value");
4741                                 }
4742
4743                                 return this.Add ((ColumnHeader) value);
4744                         }
4745
4746                         bool IList.Contains (object value)
4747                         {
4748                                 if (! (value is ColumnHeader)) {
4749                                         throw new ArgumentException ("Not of type ColumnHeader", "value");
4750                                 }
4751
4752                                 return this.Contains ((ColumnHeader) value);
4753                         }
4754
4755                         int IList.IndexOf (object value)
4756                         {
4757                                 if (! (value is ColumnHeader)) {
4758                                         throw new ArgumentException ("Not of type ColumnHeader", "value");
4759                                 }
4760
4761                                 return this.IndexOf ((ColumnHeader) value);
4762                         }
4763
4764                         void IList.Insert (int index, object value)
4765                         {
4766                                 if (! (value is ColumnHeader)) {
4767                                         throw new ArgumentException ("Not of type ColumnHeader", "value");
4768                                 }
4769
4770                                 this.Insert (index, (ColumnHeader) value);
4771                         }
4772
4773                         void IList.Remove (object value)
4774                         {
4775                                 if (! (value is ColumnHeader)) {
4776                                         throw new ArgumentException ("Not of type ColumnHeader", "value");
4777                                 }
4778
4779                                 this.Remove ((ColumnHeader) value);
4780                         }
4781
4782                         public int IndexOf (ColumnHeader value)
4783                         {
4784                                 return list.IndexOf (value);
4785                         }
4786
4787                         public virtual int IndexOfKey (string key)
4788                         {
4789                                 if (key == null || key.Length == 0)
4790                                         return -1;
4791
4792                                 for (int i = 0; i < list.Count; i++) {
4793                                         ColumnHeader col = (ColumnHeader) list [i];
4794                                         if (String.Compare (key, col.Name, true) == 0)
4795                                                 return i;
4796                                 }
4797
4798                                 return -1;
4799                         }
4800
4801                         public void Insert (int index, ColumnHeader value)
4802                         {
4803                                 // LAMESPEC: MSDOCS say greater than or equal to the value of the Count property
4804                                 // but it's really only greater.
4805                                 if (index < 0 || index > list.Count)
4806                                         throw new ArgumentOutOfRangeException ("index");
4807
4808                                 list.Insert (index, value);
4809                                 owner.AddColumn (value, index, true);
4810
4811                                 //UIA Framework event: Item added
4812                                 OnUIACollectionChangedEvent (new CollectionChangeEventArgs (CollectionChangeAction.Add, value));
4813                         }
4814
4815                         public void Insert (int index, string text)
4816                         {
4817                                 Insert (index, String.Empty, text);
4818                         }
4819
4820                         public void Insert (int index, string text, int width)
4821                         {
4822                                 Insert (index, String.Empty, text, width);
4823                         }
4824
4825                         public void Insert (int index, string key, string text)
4826                         {
4827                                 ColumnHeader colHeader = new ColumnHeader ();
4828                                 colHeader.Name = key;
4829                                 colHeader.Text = text;
4830                                 Insert (index, colHeader);
4831                         }
4832
4833                         public void Insert (int index, string key, string text, int width)
4834                         {
4835                                 ColumnHeader colHeader = new ColumnHeader (key, text, width, HorizontalAlignment.Left);
4836                                 Insert (index, colHeader);
4837                         }
4838
4839                         public void Insert (int index, string key, string text, int width, HorizontalAlignment textAlign, int imageIndex)
4840                         {
4841                                 ColumnHeader colHeader = new ColumnHeader (key, text, width, textAlign);
4842                                 colHeader.ImageIndex = imageIndex;
4843                                 Insert (index, colHeader);
4844                         }
4845
4846                         public void Insert (int index, string key, string text, int width, HorizontalAlignment textAlign, string imageKey)
4847                         {
4848                                 ColumnHeader colHeader = new ColumnHeader (key, text, width, textAlign);
4849                                 colHeader.ImageKey = imageKey;
4850                                 Insert (index, colHeader);
4851                         }
4852
4853                         public void Insert (int index, string text, int width, HorizontalAlignment textAlign)
4854                         {
4855                                 string str = text;
4856                                 ColumnHeader colHeader = new ColumnHeader (this.owner, str, textAlign, width);
4857                                 this.Insert (index, colHeader);
4858                         }
4859
4860                         public virtual void Remove (ColumnHeader column)
4861                         {
4862                                 if (!Contains (column))
4863                                         return;
4864
4865                                 list.Remove (column);
4866                                 column.SetListView (null);
4867
4868                                 int rem_display_index = column.InternalDisplayIndex;
4869                                 int [] display_indices = new int [list.Count];
4870                                 for (int i = 0; i < display_indices.Length; i++) {
4871                                         ColumnHeader col = (ColumnHeader) list [i];
4872                                         int display_index = col.InternalDisplayIndex;
4873                                         if (display_index < rem_display_index) {
4874                                                 display_indices [i] = display_index;
4875                                         } else {
4876                                                 display_indices [i] = (display_index - 1);
4877                                         }
4878                                 }
4879
4880                                 column.InternalDisplayIndex = -1;
4881                                 owner.ReorderColumns (display_indices, true);
4882
4883                                 //UIA Framework event: Item Removed
4884                                 OnUIACollectionChangedEvent (new CollectionChangeEventArgs (CollectionChangeAction.Remove, column));
4885                         }
4886
4887                         public virtual void RemoveByKey (string key)
4888                         {
4889                                 int idx = IndexOfKey (key);
4890                                 if (idx != -1)
4891                                         RemoveAt (idx);
4892                         }
4893
4894                         public virtual void RemoveAt (int index)
4895                         {
4896                                 if (index < 0 || index >= list.Count)
4897                                         throw new ArgumentOutOfRangeException ("index");
4898
4899                                 ColumnHeader col = (ColumnHeader) list [index];
4900                                 Remove (col);
4901                         }
4902                         #endregion      // Public Methods
4903
4904
4905                 }       // ColumnHeaderCollection
4906
4907                 [ListBindable (false)]
4908                 public class ListViewItemCollection : IList, ICollection, IEnumerable
4909                 {
4910                         private readonly ArrayList list;
4911                         private ListView owner;
4912                         private ListViewGroup group;
4913
4914                         #region UIA Framework Events
4915                         //NOTE:
4916                         //      We are using Reflection to add/remove internal events.
4917                         //      Class ListViewProvider uses the events.
4918                         //
4919                         //Event used to generate UIA StructureChangedEvent
4920                         static object UIACollectionChangedEvent = new object ();
4921
4922                         internal event CollectionChangeEventHandler UIACollectionChanged {
4923                                 add {
4924                                         if (owner != null)
4925                                                 owner.Events.AddHandler (UIACollectionChangedEvent, value);
4926                                 }
4927                                 remove {
4928                                         if (owner != null)
4929                                                 owner.Events.RemoveHandler (UIACollectionChangedEvent, value);
4930                                 }
4931                         }
4932
4933                         internal void OnUIACollectionChangedEvent (CollectionChangeEventArgs args)
4934                         {
4935                                 if (owner == null)
4936                                         return;
4937
4938                                 CollectionChangeEventHandler eh
4939                                         = (CollectionChangeEventHandler) owner.Events [UIACollectionChangedEvent];
4940                                 if (eh != null)
4941                                         eh (owner, args);
4942                         }
4943
4944                         #endregion UIA Framework Events
4945
4946                         // The collection can belong to a ListView (main) or to a ListViewGroup (sub-collection)
4947                         // In the later case ListViewItem.ListView never gets modified
4948                         private bool is_main_collection = true;
4949
4950                         #region Public Constructor
4951                         public ListViewItemCollection (ListView owner)
4952                         {
4953                                 list = new ArrayList (0);
4954                                 this.owner = owner;
4955                         }
4956                         #endregion      // Public Constructor
4957
4958                         internal ListViewItemCollection (ListView owner, ListViewGroup group) : this (owner)
4959                         {
4960                                 this.group = group;
4961                                 is_main_collection = false;
4962                         }
4963
4964                         #region Public Properties
4965                         [Browsable (false)]
4966                         public int Count {
4967                                 get {
4968                                         if (owner != null && owner.VirtualMode)
4969                                                 return owner.VirtualListSize;
4970
4971                                         return list.Count;
4972                                 }
4973                         }
4974
4975                         public bool IsReadOnly {
4976                                 get { return false; }
4977                         }
4978
4979                         public virtual ListViewItem this [int index] {
4980                                 get {
4981                                         if (index < 0 || index >= Count)
4982                                                 throw new ArgumentOutOfRangeException ("index");
4983
4984                                         if (owner != null && owner.VirtualMode)
4985                                                 return RetrieveVirtualItemFromOwner (index);
4986                                         return (ListViewItem) list [index];
4987                                 }
4988
4989                                 set {
4990                                         if (index < 0 || index >= Count)
4991                                                 throw new ArgumentOutOfRangeException ("index");
4992
4993                                         if (owner != null && owner.VirtualMode)
4994                                                 throw new InvalidOperationException ();
4995
4996                                         if (list.Contains (value))
4997                                                 throw new ArgumentException ("An item cannot be added more than once. To add an item again, you need to clone it.", "value");
4998
4999                                         if (value.ListView != null && value.ListView != owner)
5000                                                 throw new ArgumentException ("Cannot add or insert the item '" + value.Text + "' in more than one place. You must first remove it from its current location or clone it.", "value");
5001
5002                                         if (is_main_collection)
5003                                                 value.Owner = owner;
5004                                         else {
5005                                                 if (value.Group != null)
5006                                                         value.Group.Items.Remove (value);
5007
5008                                                 value.SetGroup (group);
5009                                         }
5010
5011                                         //UIA Framework event: Item Replaced
5012                                         OnUIACollectionChangedEvent (new CollectionChangeEventArgs (CollectionChangeAction.Remove, list [index]));
5013
5014                                         list [index] = value;
5015
5016                                         CollectionChanged (true);
5017
5018                                         //UIA Framework event: Item Replaced
5019                                         OnUIACollectionChangedEvent (new CollectionChangeEventArgs (CollectionChangeAction.Add, value));
5020
5021                                 }
5022                         }
5023
5024                         public virtual ListViewItem this [string key] {
5025                                 get {
5026                                         int idx = IndexOfKey (key);
5027                                         if (idx == -1)
5028                                                 return null;
5029
5030                                         return this [idx];
5031                                 }
5032                         }
5033
5034                         bool ICollection.IsSynchronized {
5035                                 get { return true; }
5036                         }
5037
5038                         object ICollection.SyncRoot {
5039                                 get { return this; }
5040                         }
5041
5042                         bool IList.IsFixedSize {
5043                                 get { return list.IsFixedSize; }
5044                         }
5045
5046                         object IList.this [int index] {
5047                                 get { return this [index]; }
5048                                 set {
5049                                         //UIA Framework event: Item Replaced
5050                                         OnUIACollectionChangedEvent (new CollectionChangeEventArgs (CollectionChangeAction.Remove, this [index]));
5051
5052                                         if (value is ListViewItem)
5053                                                 this [index] = (ListViewItem) value;
5054                                         else
5055                                                 this [index] = new ListViewItem (value.ToString ());
5056
5057                                         OnChange ();
5058                                         //UIA Framework event: Item Replaced
5059                                         OnUIACollectionChangedEvent (new CollectionChangeEventArgs (CollectionChangeAction.Add, value));
5060                                 }
5061                         }
5062                         #endregion      // Public Properties
5063
5064                         #region Public Methods
5065                         public virtual ListViewItem Add (ListViewItem value)
5066                         {
5067                                 if (owner != null && owner.VirtualMode)
5068                                         throw new InvalidOperationException ();
5069
5070                                 AddItem (value);
5071
5072                                 // Item is ignored until it has been added to the ListView
5073                                 if (is_main_collection || value.ListView != null)
5074                                         CollectionChanged (true);
5075
5076                                 //UIA Framework event: Item Added
5077                                 OnUIACollectionChangedEvent (new CollectionChangeEventArgs (CollectionChangeAction.Add, value));
5078
5079                                 return value;
5080                         }
5081
5082                         public virtual ListViewItem Add (string text)
5083                         {
5084                                 ListViewItem item = new ListViewItem (text);
5085                                 return this.Add (item);
5086                         }
5087
5088                         public virtual ListViewItem Add (string text, int imageIndex)
5089                         {
5090                                 ListViewItem item = new ListViewItem (text, imageIndex);
5091                                 return this.Add (item);
5092                         }
5093
5094                         public virtual ListViewItem Add (string text, string imageKey)
5095                         {
5096                                 ListViewItem item = new ListViewItem (text, imageKey);
5097                                 return this.Add (item);
5098                         }
5099
5100                         public virtual ListViewItem Add (string key, string text, int imageIndex)
5101                         {
5102                                 ListViewItem item = new ListViewItem (text, imageIndex);
5103                                 item.Name = key;
5104                                 return this.Add (item);
5105                         }
5106
5107                         public virtual ListViewItem Add (string key, string text, string imageKey)
5108                         {
5109                                 ListViewItem item = new ListViewItem (text, imageKey);
5110                                 item.Name = key;
5111                                 return this.Add (item);
5112                         }
5113
5114                         public void AddRange (ListViewItem [] items)
5115                         {
5116                                 if (items == null)
5117                                         throw new ArgumentNullException ("Argument cannot be null!", "items");
5118                                 if (owner != null && owner.VirtualMode)
5119                                         throw new InvalidOperationException ();
5120
5121                                 owner.BeginUpdate ();
5122
5123                                 foreach (ListViewItem item in items) {
5124                                         AddItem (item);
5125
5126                                         //UIA Framework event: Item Added
5127                                         OnUIACollectionChangedEvent (new CollectionChangeEventArgs (CollectionChangeAction.Add, item));
5128                                 }
5129
5130                                 owner.EndUpdate ();
5131
5132                                 CollectionChanged (true);
5133                         }
5134
5135                         public void AddRange (ListViewItemCollection items)
5136                         {
5137                                 if (items == null)
5138                                         throw new ArgumentNullException ("Argument cannot be null!", "items");
5139
5140                                 ListViewItem[] itemArray = new ListViewItem[items.Count];
5141                                 items.CopyTo (itemArray,0);
5142                                 this.AddRange (itemArray);
5143                         }
5144
5145                         public virtual void Clear ()
5146                         {
5147                                 if (owner != null && owner.VirtualMode)
5148                                         throw new InvalidOperationException ();
5149                                 if (is_main_collection && owner != null) {
5150                                         owner.SetFocusedItem (-1);
5151                                         owner.h_scroll.Value = owner.v_scroll.Value = 0;
5152
5153                                         // first remove any item in the groups that *are* part of this LV too
5154                                         foreach (ListViewGroup group in owner.groups)
5155                                                 group.Items.ClearItemsWithSameListView ();
5156
5157                                         foreach (ListViewItem item in list) {
5158                                                 owner.item_control.CancelEdit (item);
5159                                                 item.Owner = null;
5160                                         }
5161                                 }
5162                                 else
5163                                         foreach (ListViewItem item in list)
5164                                                 item.SetGroup (null);
5165
5166                                 list.Clear ();
5167                                 CollectionChanged (false);
5168
5169                                 //UIA Framework event: Items Removed
5170                                 OnUIACollectionChangedEvent (new CollectionChangeEventArgs (CollectionChangeAction.Refresh, null));
5171
5172                         }
5173
5174                         // This method is intended to be used from ListViewGroup.Items, not from ListView.Items,
5175                         // added for performance reasons (avoid calling manually Remove for every item on ListViewGroup.Items)
5176                         void ClearItemsWithSameListView ()
5177                         {
5178                                 if (is_main_collection)
5179                                         return;
5180
5181                                 int counter = list.Count - 1;
5182                                 while (counter >= 0) {
5183                                         ListViewItem item = list [counter] as ListViewItem;
5184
5185                                         // remove only if the items in group have being added to the ListView too
5186                                         if (item.ListView == group.ListView) {
5187                                                 list.RemoveAt (counter);
5188                                                 item.SetGroup (null);
5189                                         }
5190
5191                                         counter--;
5192                                 }
5193                         }
5194
5195                         public bool Contains (ListViewItem item)
5196                         {
5197                                 return IndexOf (item) != -1;
5198                         }
5199
5200                         public virtual bool ContainsKey (string key)
5201                         {
5202                                 return IndexOfKey (key) != -1;
5203                         }
5204
5205                         public void CopyTo (Array dest, int index)
5206                         {
5207                                 list.CopyTo (dest, index);
5208                         }
5209
5210                         public ListViewItem [] Find (string key, bool searchAllSubItems)
5211                         {
5212                                 if (key == null)
5213                                         return new ListViewItem [0];
5214
5215                                 List<ListViewItem> temp_list = new List<ListViewItem> ();
5216
5217                                 for (int i = 0; i < list.Count; i++) {
5218                                         ListViewItem lvi = (ListViewItem) list [i];
5219                                         if (String.Compare (key, lvi.Name, true) == 0)
5220                                                 temp_list.Add (lvi);
5221                                 }
5222
5223                                 ListViewItem [] retval = new ListViewItem [temp_list.Count];
5224                                 temp_list.CopyTo (retval);
5225
5226                                 return retval;
5227                         }
5228
5229                         public IEnumerator GetEnumerator ()
5230                         {
5231                                 if (owner != null && owner.VirtualMode)
5232                                         throw new InvalidOperationException ();
5233
5234                                 // This enumerator makes a copy of the collection so
5235                                 // it can be deleted from in a foreach
5236                                 return new Control.ControlCollection.ControlCollectionEnumerator (list);
5237                         }
5238
5239                         int IList.Add (object item)
5240                         {
5241                                 int result;
5242                                 ListViewItem li;
5243
5244                                 if (owner != null && owner.VirtualMode)
5245                                         throw new InvalidOperationException ();
5246
5247                                 if (item is ListViewItem) {
5248                                         li = (ListViewItem) item;
5249                                         if (list.Contains (li))
5250                                                 throw new ArgumentException ("An item cannot be added more than once. To add an item again, you need to clone it.", "item");
5251
5252                                         if (li.ListView != null && li.ListView != owner)
5253                                                 throw new ArgumentException ("Cannot add or insert the item '" + li.Text + "' in more than one place. You must first remove it from its current location or clone it.", "item");
5254                                 }
5255                                 else
5256                                         li = new ListViewItem (item.ToString ());
5257
5258                                 li.Owner = owner;
5259
5260
5261                                 result = list.Add (li);
5262                                 CollectionChanged (true);
5263
5264                                 //UIA Framework event: Item Added
5265                                 OnUIACollectionChangedEvent (new CollectionChangeEventArgs (CollectionChangeAction.Add, li));
5266
5267                                 return result;
5268                         }
5269
5270                         bool IList.Contains (object item)
5271                         {
5272                                 return Contains ((ListViewItem) item);
5273                         }
5274
5275                         int IList.IndexOf (object item)
5276                         {
5277                                 return IndexOf ((ListViewItem) item);
5278                         }
5279
5280                         void IList.Insert (int index, object item)
5281                         {
5282                                 if (item is ListViewItem)
5283                                         this.Insert (index, (ListViewItem) item);
5284                                 else
5285                                         this.Insert (index, item.ToString ());
5286
5287                                 //UIA Framework event: Item Added
5288                                 OnUIACollectionChangedEvent (new CollectionChangeEventArgs (CollectionChangeAction.Add, this [index]));
5289                         }
5290
5291                         void IList.Remove (object item)
5292                         {
5293                                 Remove ((ListViewItem) item);
5294                         }
5295
5296                         public int IndexOf (ListViewItem item)
5297                         {
5298                                 if (owner != null && owner.VirtualMode) {
5299                                         for (int i = 0; i < Count; i++)
5300                                                 if (RetrieveVirtualItemFromOwner (i) == item)
5301                                                         return i;
5302
5303                                         return -1;
5304                                 }
5305
5306                                 return list.IndexOf (item);
5307                         }
5308
5309                         public virtual int IndexOfKey (string key)
5310                         {
5311                                 if (key == null || key.Length == 0)
5312                                         return -1;
5313
5314                                 for (int i = 0; i < Count; i++) {
5315                                         ListViewItem lvi = this [i];
5316                                         if (String.Compare (key, lvi.Name, true) == 0)
5317                                                 return i;
5318                                 }
5319
5320                                 return -1;
5321                         }
5322
5323                         public ListViewItem Insert (int index, ListViewItem item)
5324                         {
5325                                 if (index < 0 || index > list.Count)
5326                                         throw new ArgumentOutOfRangeException ("index");
5327
5328                                 if (owner != null && owner.VirtualMode)
5329                                         throw new InvalidOperationException ();
5330
5331                                 if (list.Contains (item))
5332                                         throw new ArgumentException ("An item cannot be added more than once. To add an item again, you need to clone it.", "item");
5333
5334                                 if (item.ListView != null && item.ListView != owner)
5335                                         throw new ArgumentException ("Cannot add or insert the item '" + item.Text + "' in more than one place. You must first remove it from its current location or clone it.", "item");
5336
5337                                 if (is_main_collection)
5338                                         item.Owner = owner;
5339                                 else {
5340                                         if (item.Group != null)
5341                                                 item.Group.Items.Remove (item);
5342
5343                                         item.SetGroup (group);
5344                                 }
5345
5346                                 list.Insert (index, item);
5347
5348                                 if (is_main_collection || item.ListView != null)
5349                                         CollectionChanged (true);
5350
5351                                 // force an update of the selected info if the new item is selected.
5352                                 if (item.Selected)
5353                                         item.SetSelectedCore (true);
5354                                 //UIA Framework event: Item Added
5355                                 OnUIACollectionChangedEvent (new CollectionChangeEventArgs (CollectionChangeAction.Add, item));
5356
5357                                 return item;
5358                         }
5359
5360                         public ListViewItem Insert (int index, string text)
5361                         {
5362                                 return this.Insert (index, new ListViewItem (text));
5363                         }
5364
5365                         public ListViewItem Insert (int index, string text, int imageIndex)
5366                         {
5367                                 return this.Insert (index, new ListViewItem (text, imageIndex));
5368                         }
5369
5370                         public ListViewItem Insert (int index, string text, string imageKey)
5371                         {
5372                                 ListViewItem lvi = new ListViewItem (text, imageKey);
5373                                 return Insert (index, lvi);
5374                         }
5375
5376                         public virtual ListViewItem Insert (int index, string key, string text, int imageIndex)
5377                         {
5378                                 ListViewItem lvi = new ListViewItem (text, imageIndex);
5379                                 lvi.Name = key;
5380                                 return Insert (index, lvi);
5381                         }
5382
5383                         public virtual ListViewItem Insert (int index, string key, string text, string imageKey)
5384                         {
5385                                 ListViewItem lvi = new ListViewItem (text, imageKey);
5386                                 lvi.Name = key;
5387                                 return Insert (index, lvi);
5388                         }
5389
5390                         public virtual void Remove (ListViewItem item)
5391                         {
5392                                 if (owner != null && owner.VirtualMode)
5393                                         throw new InvalidOperationException ();
5394
5395                                 int idx = list.IndexOf (item);
5396                                 if (idx != -1)
5397                                         RemoveAt (idx);
5398                         }
5399
5400                         public virtual void RemoveAt (int index)
5401                         {
5402                                 if (index < 0 || index >= Count)
5403                                         throw new ArgumentOutOfRangeException ("index");
5404
5405                                 if (owner != null && owner.VirtualMode)
5406                                         throw new InvalidOperationException ();
5407
5408                                 ListViewItem item = (ListViewItem) list [index];
5409
5410                                 bool selection_changed = false;
5411                                 if (is_main_collection && owner != null) {
5412
5413                                         int display_index = item.DisplayIndex;
5414                                         if (item.Focused && display_index + 1 == Count) // Last item
5415                                                 owner.SetFocusedItem (display_index == 0 ? -1 : display_index - 1);
5416
5417                                         selection_changed = owner.SelectedIndices.Contains (index);
5418                                         owner.item_control.CancelEdit (item);
5419                                 }
5420
5421                                 list.RemoveAt (index);
5422
5423                                 if (is_main_collection) {
5424                                         item.Owner = null;
5425                                         if (item.Group != null)
5426                                                 item.Group.Items.Remove (item);
5427                                 } else
5428                                         item.SetGroup (null);
5429
5430                                 CollectionChanged (false);
5431                                 if (selection_changed && owner != null)
5432                                         owner.OnSelectedIndexChanged (EventArgs.Empty);
5433
5434
5435                                 //UIA Framework event: Item Removed
5436                                 OnUIACollectionChangedEvent (new CollectionChangeEventArgs (CollectionChangeAction.Remove, item));
5437                         }
5438
5439                         public virtual void RemoveByKey (string key)
5440                         {
5441                                 int idx = IndexOfKey (key);
5442                                 if (idx != -1)
5443                                         RemoveAt (idx);
5444                         }
5445
5446                         #endregion      // Public Methods
5447
5448                         internal ListView Owner {
5449                                 get {
5450                                         return owner;
5451                                 }
5452                                 set {
5453                                         owner = value;
5454                                 }
5455                         }
5456
5457                         internal ListViewGroup Group {
5458                                 get {
5459                                         return group;
5460                                 }
5461                                 set {
5462                                         group = value;
5463                                 }
5464                         }
5465
5466                         void AddItem (ListViewItem value)
5467                         {
5468                                 if (list.Contains (value))
5469                                         throw new ArgumentException ("An item cannot be added more than once. To add an item again, you need to clone it.", "value");
5470
5471                                 if (value.ListView != null && value.ListView != owner)
5472                                         throw new ArgumentException ("Cannot add or insert the item '" + value.Text + "' in more than one place. You must first remove it from its current location or clone it.", "value");
5473                                 if (is_main_collection)
5474                                         value.Owner = owner;
5475                                 else {
5476                                         if (value.Group != null)
5477                                                 value.Group.Items.Remove (value);
5478
5479                                         value.SetGroup (group);
5480                                 }
5481
5482                                 list.Add (value);
5483
5484                                 // force an update of the selected info if the new item is selected.
5485                                 if (value.Selected)
5486                                         value.SetSelectedCore (true);
5487                         }
5488
5489                         void CollectionChanged (bool sort)
5490                         {
5491                                 if (owner != null) {
5492                                         if (sort)
5493                                                 owner.Sort (false);
5494
5495                                         OnChange ();
5496                                         owner.Redraw (true);
5497                                 }
5498                         }
5499
5500                         ListViewItem RetrieveVirtualItemFromOwner (int displayIndex)
5501                         {
5502                                 RetrieveVirtualItemEventArgs args = new RetrieveVirtualItemEventArgs (displayIndex);
5503
5504                                 owner.OnRetrieveVirtualItem (args);
5505                                 ListViewItem retval = args.Item;
5506                                 retval.Owner = owner;
5507                                 retval.DisplayIndex = displayIndex;
5508                                 retval.Layout ();
5509
5510                                 return retval;
5511                         }
5512
5513                         internal event CollectionChangedHandler Changed;
5514
5515                         internal void Sort (IComparer comparer)
5516                         {
5517                                 list.Sort (comparer);
5518                                 OnChange ();
5519                         }
5520
5521                         internal void OnChange ()
5522                         {
5523                                 if (Changed != null)
5524                                         Changed ();
5525                         }
5526                 }       // ListViewItemCollection
5527
5528
5529                 // In normal mode, the selection information resides in the Items,
5530                 // making SelectedIndexCollection.List read-only
5531                 //
5532                 // In virtual mode, SelectedIndexCollection directly saves the selection
5533                 // information, instead of getting it from Items, making List read-and-write
5534                 [ListBindable (false)]
5535                 public class SelectedIndexCollection : IList, ICollection, IEnumerable
5536                 {
5537                         private readonly ListView owner;
5538                         private ArrayList list;
5539
5540                         #region Public Constructor
5541                         public SelectedIndexCollection (ListView owner)
5542                         {
5543                                 this.owner = owner;
5544                                 owner.Items.Changed += new CollectionChangedHandler (ItemsCollection_Changed);
5545                         }
5546                         #endregion      // Public Constructor
5547
5548                         #region Public Properties
5549                         [Browsable (false)]
5550                         public int Count {
5551                                 get {
5552                                         if (!owner.is_selection_available)
5553                                                 return 0;
5554
5555                                         return List.Count;
5556                                 }
5557                         }
5558
5559                         public bool IsReadOnly {
5560                                 get {
5561                                         return false;
5562                                 }
5563                         }
5564
5565                         public int this [int index] {
5566                                 get {
5567                                         if (!owner.is_selection_available || index < 0 || index >= List.Count)
5568                                                 throw new ArgumentOutOfRangeException ("index");
5569
5570                                         return (int) List [index];
5571                                 }
5572                         }
5573
5574                         bool ICollection.IsSynchronized {
5575                                 get { return false; }
5576                         }
5577
5578                         object ICollection.SyncRoot {
5579                                 get { return this; }
5580                         }
5581
5582                         bool IList.IsFixedSize {
5583                                 get {
5584                                         return false;
5585                                 }
5586                         }
5587
5588                         object IList.this [int index] {
5589                                 get { return this [index]; }
5590                                 set { throw new NotSupportedException ("SetItem operation is not supported."); }
5591                         }
5592                         #endregion      // Public Properties
5593
5594                         #region Public Methods
5595                         public int Add (int itemIndex)
5596                         {
5597                                 if (itemIndex < 0 || itemIndex >= owner.Items.Count)
5598                                         throw new ArgumentOutOfRangeException ("index");
5599
5600                                 if (owner.virtual_mode && !owner.is_selection_available)
5601                                         return -1;
5602
5603                                 owner.Items [itemIndex].Selected = true;
5604
5605                                 if (!owner.is_selection_available)
5606                                         return 0;
5607
5608                                 return List.Count;
5609                         }
5610
5611                         public void Clear ()
5612                         {
5613                                 if (!owner.is_selection_available)
5614                                         return;
5615
5616                                 int [] indexes = (int []) List.ToArray (typeof (int));
5617                                 foreach (int index in indexes)
5618                                         owner.Items [index].Selected = false;
5619                         }
5620
5621                         public bool Contains (int selectedIndex)
5622                         {
5623                                 return IndexOf (selectedIndex) != -1;
5624                         }
5625
5626                         public void CopyTo (Array dest, int index)
5627                         {
5628                                 List.CopyTo (dest, index);
5629                         }
5630
5631                         public IEnumerator GetEnumerator ()
5632                         {
5633                                 return List.GetEnumerator ();
5634                         }
5635
5636                         int IList.Add (object value)
5637                         {
5638                                 throw new NotSupportedException ("Add operation is not supported.");
5639                         }
5640
5641                         void IList.Clear ()
5642                         {
5643                                 Clear ();
5644                         }
5645
5646                         bool IList.Contains (object selectedIndex)
5647                         {
5648                                 if (!(selectedIndex is int))
5649                                         return false;
5650                                 return Contains ((int) selectedIndex);
5651                         }
5652
5653                         int IList.IndexOf (object selectedIndex)
5654                         {
5655                                 if (!(selectedIndex is int))
5656                                         return -1;
5657                                 return IndexOf ((int) selectedIndex);
5658                         }
5659
5660                         void IList.Insert (int index, object value)
5661                         {
5662                                 throw new NotSupportedException ("Insert operation is not supported.");
5663                         }
5664
5665                         void IList.Remove (object value)
5666                         {
5667                                 throw new NotSupportedException ("Remove operation is not supported.");
5668                         }
5669
5670                         void IList.RemoveAt (int index)
5671                         {
5672                                 throw new NotSupportedException ("RemoveAt operation is not supported.");
5673                         }
5674
5675                         public int IndexOf (int selectedIndex)
5676                         {
5677                                 if (!owner.is_selection_available)
5678                                         return -1;
5679
5680                                 return List.IndexOf (selectedIndex);
5681                         }
5682
5683                         public void Remove (int itemIndex)
5684                         {
5685                                 if (itemIndex < 0 || itemIndex >= owner.Items.Count)
5686                                         throw new ArgumentOutOfRangeException ("itemIndex");
5687
5688                                 owner.Items [itemIndex].Selected = false;
5689                         }
5690                         #endregion      // Public Methods
5691
5692                         internal ArrayList List {
5693                                 get {
5694                                         if (list == null) {
5695                                                 list = new ArrayList ();
5696                                                 if (!owner.VirtualMode)
5697                                                 for (int i = 0; i < owner.Items.Count; i++) {
5698                                                         if (owner.Items [i].Selected)
5699                                                                 list.Add (i);
5700                                                 }
5701                                         }
5702                                         return list;
5703                                 }
5704                         }
5705
5706                         internal void Reset ()
5707                         {
5708                                 // force re-population of list
5709                                 list = null;
5710                         }
5711
5712                         private void ItemsCollection_Changed ()
5713                         {
5714                                 Reset ();
5715                         }
5716
5717                         internal void RemoveIndex (int index)
5718                         {
5719                                 int idx = List.BinarySearch (index);
5720                                 if (idx != -1)
5721                                         List.RemoveAt (idx);
5722                         }
5723
5724                         // actually store index in the collection
5725                         // also, keep the collection sorted, as .Net does
5726                         internal void InsertIndex (int index)
5727                         {
5728                                 int iMin = 0;
5729                                 int iMax = List.Count - 1;
5730                                 while (iMin <= iMax) {
5731                                         int iMid = (iMin + iMax) / 2;
5732                                         int current_index = (int) List [iMid];
5733
5734                                         if (current_index == index)
5735                                                 return; // Already added
5736                                         if (current_index > index)
5737                                                 iMax = iMid - 1;
5738                                         else
5739                                                 iMin = iMid + 1;
5740                                 }
5741
5742                                 List.Insert (iMin, index);
5743                         }
5744
5745                 }       // SelectedIndexCollection
5746
5747                 [ListBindable (false)]
5748                 public class SelectedListViewItemCollection : IList, ICollection, IEnumerable
5749                 {
5750                         private readonly ListView owner;
5751
5752                         #region Public Constructor
5753                         public SelectedListViewItemCollection (ListView owner)
5754                         {
5755                                 this.owner = owner;
5756                         }
5757                         #endregion      // Public Constructor
5758
5759                         #region Public Properties
5760                         [Browsable (false)]
5761                         public int Count {
5762                                 get {
5763                                         return owner.SelectedIndices.Count;
5764                                 }
5765                         }
5766
5767                         public bool IsReadOnly {
5768                                 get { return true; }
5769                         }
5770
5771                         public ListViewItem this [int index] {
5772                                 get {
5773                                         if (!owner.is_selection_available || index < 0 || index >= Count)
5774                                                 throw new ArgumentOutOfRangeException ("index");
5775
5776                                         int item_index = owner.SelectedIndices [index];
5777                                         return owner.Items [item_index];
5778                                 }
5779                         }
5780
5781                         public virtual ListViewItem this [string key] {
5782                                 get {
5783                                         int idx = IndexOfKey (key);
5784                                         if (idx == -1)
5785                                                 return null;
5786
5787                                         return this [idx];
5788                                 }
5789                         }
5790
5791                         bool ICollection.IsSynchronized {
5792                                 get { return false; }
5793                         }
5794
5795                         object ICollection.SyncRoot {
5796                                 get { return this; }
5797                         }
5798
5799                         bool IList.IsFixedSize {
5800                                 get { return true; }
5801                         }
5802
5803                         object IList.this [int index] {
5804                                 get { return this [index]; }
5805                                 set { throw new NotSupportedException ("SetItem operation is not supported."); }
5806                         }
5807                         #endregion      // Public Properties
5808
5809                         #region Public Methods
5810                         public void Clear ()
5811                         {
5812                                 owner.SelectedIndices.Clear ();
5813                         }
5814
5815                         public bool Contains (ListViewItem item)
5816                         {
5817                                 return IndexOf (item) != -1;
5818                         }
5819
5820                         public virtual bool ContainsKey (string key)
5821                         {
5822                                 return IndexOfKey (key) != -1;
5823                         }
5824
5825                         public void CopyTo (Array dest, int index)
5826                         {
5827                                 if (!owner.is_selection_available)
5828                                         return;
5829                                 if (index > Count) // Throws ArgumentException instead of IOOR exception
5830                                         throw new ArgumentException ("index");
5831
5832                                 for (int i = 0; i < Count; i++)
5833                                         dest.SetValue (this [i], index++);
5834                         }
5835
5836                         public IEnumerator GetEnumerator ()
5837                         {
5838                                 if (!owner.is_selection_available)
5839                                         return (new ListViewItem [0]).GetEnumerator ();
5840
5841                                 ListViewItem [] items = new ListViewItem [Count];
5842                                 for (int i = 0; i < Count; i++)
5843                                         items [i] = this [i];
5844
5845                                 return items.GetEnumerator ();
5846                         }
5847
5848                         int IList.Add (object value)
5849                         {
5850                                 throw new NotSupportedException ("Add operation is not supported.");
5851                         }
5852
5853                         bool IList.Contains (object item)
5854                         {
5855                                 if (!(item is ListViewItem))
5856                                         return false;
5857                                 return Contains ((ListViewItem) item);
5858                         }
5859
5860                         int IList.IndexOf (object item)
5861                         {
5862                                 if (!(item is ListViewItem))
5863                                         return -1;
5864                                 return IndexOf ((ListViewItem) item);
5865                         }
5866
5867                         void IList.Insert (int index, object value)
5868                         {
5869                                 throw new NotSupportedException ("Insert operation is not supported.");
5870                         }
5871
5872                         void IList.Remove (object value)
5873                         {
5874                                 throw new NotSupportedException ("Remove operation is not supported.");
5875                         }
5876
5877                         void IList.RemoveAt (int index)
5878                         {
5879                                 throw new NotSupportedException ("RemoveAt operation is not supported.");
5880                         }
5881
5882                         public int IndexOf (ListViewItem item)
5883                         {
5884                                 if (!owner.is_selection_available)
5885                                         return -1;
5886
5887                                 for (int i = 0; i < Count; i++)
5888                                         if (this [i] == item)
5889                                                 return i;
5890
5891                                 return -1;
5892                         }
5893
5894                         public virtual int IndexOfKey (string key)
5895                         {
5896                                 if (!owner.is_selection_available || key == null || key.Length == 0)
5897                                         return -1;
5898
5899                                 for (int i = 0; i < Count; i++) {
5900                                         ListViewItem item = this [i];
5901                                         if (String.Compare (item.Name, key, true) == 0)
5902                                                 return i;
5903                                 }
5904
5905                                 return -1;
5906                         }
5907                         #endregion      // Public Methods
5908
5909                 }       // SelectedListViewItemCollection
5910
5911                 internal delegate void CollectionChangedHandler ();
5912
5913                 struct ItemMatrixLocation
5914                 {
5915                         int row;
5916                         int col;
5917
5918                         public ItemMatrixLocation (int row, int col)
5919                         {
5920                                 this.row = row;
5921                                 this.col = col;
5922
5923                         }
5924
5925                         public int Col {
5926                                 get {
5927                                         return col;
5928                                 }
5929                                 set {
5930                                         col = value;
5931                                 }
5932                         }
5933
5934                         public int Row {
5935                                 get {
5936                                         return row;
5937                                 }
5938                                 set {
5939                                         row = value;
5940                                 }
5941                         }
5942
5943                 }
5944
5945                 #endregion // Subclasses
5946                 protected override void OnResize (EventArgs e)
5947                 {
5948                         base.OnResize (e);
5949                 }
5950
5951                 protected override void OnMouseLeave (EventArgs e)
5952                 {
5953                         base.OnMouseLeave (e);
5954                 }
5955
5956                 //
5957                 // ColumnReorder event
5958                 //
5959                 static object ColumnReorderedEvent = new object ();
5960                 public event ColumnReorderedEventHandler ColumnReordered {
5961                         add { Events.AddHandler (ColumnReorderedEvent, value); }
5962                         remove { Events.RemoveHandler (ColumnReorderedEvent, value); }
5963                 }
5964
5965                 protected virtual void OnColumnReordered (ColumnReorderedEventArgs e)
5966                 {
5967                         ColumnReorderedEventHandler creh = (ColumnReorderedEventHandler) (Events [ColumnReorderedEvent]);
5968
5969                         if (creh != null)
5970                                 creh (this, e);
5971                 }
5972
5973                 //
5974                 // ColumnWidthChanged
5975                 //
5976                 static object ColumnWidthChangedEvent = new object ();
5977                 public event ColumnWidthChangedEventHandler ColumnWidthChanged {
5978                         add { Events.AddHandler (ColumnWidthChangedEvent, value); }
5979                         remove { Events.RemoveHandler (ColumnWidthChangedEvent, value); }
5980                 }
5981
5982                 protected virtual void OnColumnWidthChanged (ColumnWidthChangedEventArgs e)
5983                 {
5984                         ColumnWidthChangedEventHandler eh = (ColumnWidthChangedEventHandler) (Events[ColumnWidthChangedEvent]);
5985                         if (eh != null)
5986                                 eh (this, e);
5987                 }
5988
5989                 void RaiseColumnWidthChanged (int resize_column)
5990                 {
5991                         ColumnWidthChangedEventArgs n = new ColumnWidthChangedEventArgs (resize_column);
5992
5993                         OnColumnWidthChanged (n);
5994                 }
5995
5996                 //
5997                 // ColumnWidthChanging
5998                 //
5999                 static object ColumnWidthChangingEvent = new object ();
6000                 public event ColumnWidthChangingEventHandler ColumnWidthChanging {
6001                         add { Events.AddHandler (ColumnWidthChangingEvent, value); }
6002                         remove { Events.RemoveHandler (ColumnWidthChangingEvent, value); }
6003                 }
6004
6005                 protected virtual void OnColumnWidthChanging (ColumnWidthChangingEventArgs e)
6006                 {
6007                         ColumnWidthChangingEventHandler cwceh = (ColumnWidthChangingEventHandler) (Events[ColumnWidthChangingEvent]);
6008                         if (cwceh != null)
6009                                 cwceh (this, e);
6010                 }
6011
6012                 //
6013                 // 2.0 profile based implementation
6014                 //
6015                 bool CanProceedWithResize (ColumnHeader col, int width)
6016                 {
6017                         ColumnWidthChangingEventHandler cwceh = (ColumnWidthChangingEventHandler) (Events[ColumnWidthChangingEvent]);
6018                         if (cwceh == null)
6019                                 return true;
6020
6021                         ColumnWidthChangingEventArgs changing = new ColumnWidthChangingEventArgs (col.Index, width);
6022                         cwceh (this, changing);
6023                         return !changing.Cancel;
6024                 }
6025
6026                 internal void RaiseColumnWidthChanged (ColumnHeader column)
6027                 {
6028                         int index = Columns.IndexOf (column);
6029                         RaiseColumnWidthChanged (index);
6030                 }
6031
6032
6033                 #region UIA Framework: Methods, Properties and Events
6034
6035                 static object UIALabelEditChangedEvent = new object ();
6036                 static object UIAShowGroupsChangedEvent = new object ();
6037                 static object UIAMultiSelectChangedEvent = new object ();
6038                 static object UIAViewChangedEvent = new object ();
6039                 static object UIACheckBoxesChangedEvent = new object ();
6040                 static object UIAFocusedItemChangedEvent = new object ();
6041
6042                 internal Rectangle UIAHeaderControl {
6043                         get { return header_control.Bounds; }
6044                 }
6045
6046                 internal int UIAColumns {
6047                         get { return cols; }
6048                 }
6049
6050                 internal int UIARows {
6051                         get { return rows; }
6052                 }
6053
6054                 internal ListViewGroup UIADefaultListViewGroup
6055                 {
6056                         get { return groups.DefaultGroup; }
6057                 }
6058
6059                 internal ScrollBar UIAHScrollBar {
6060                         get { return h_scroll; }
6061                 }
6062
6063                 internal ScrollBar UIAVScrollBar {
6064                         get { return v_scroll; }
6065                 }
6066
6067                 internal event EventHandler UIAShowGroupsChanged {
6068                         add { Events.AddHandler (UIAShowGroupsChangedEvent, value); }
6069                         remove { Events.RemoveHandler (UIAShowGroupsChangedEvent, value); }
6070                 }
6071
6072                 internal event EventHandler UIACheckBoxesChanged {
6073                         add { Events.AddHandler (UIACheckBoxesChangedEvent, value); }
6074                         remove { Events.RemoveHandler (UIACheckBoxesChangedEvent, value); }
6075                 }
6076
6077                 internal event EventHandler UIAMultiSelectChanged {
6078                         add { Events.AddHandler (UIAMultiSelectChangedEvent, value); }
6079                         remove { Events.RemoveHandler (UIAMultiSelectChangedEvent, value); }
6080                 }
6081
6082                 internal event EventHandler UIALabelEditChanged {
6083                         add { Events.AddHandler (UIALabelEditChangedEvent, value); }
6084                         remove { Events.RemoveHandler (UIALabelEditChangedEvent, value); }
6085                 }
6086
6087                 internal event EventHandler UIAViewChanged {
6088                         add { Events.AddHandler (UIAViewChangedEvent, value); }
6089                         remove { Events.RemoveHandler (UIAViewChangedEvent, value); }
6090                 }
6091
6092                 internal event EventHandler UIAFocusedItemChanged {
6093                         add { Events.AddHandler (UIAFocusedItemChangedEvent, value); }
6094                         remove { Events.RemoveHandler (UIAFocusedItemChangedEvent, value); }
6095                 }
6096
6097                 internal Rectangle UIAGetHeaderBounds (ListViewGroup group)
6098                 {
6099                         return group.HeaderBounds;
6100                 }
6101
6102                 internal int UIAItemsLocationLength
6103                 {
6104                         get { return items_location.Length; }
6105                 }
6106
6107                 private void OnUIACheckBoxesChanged ()
6108                 {
6109                         EventHandler eh = (EventHandler) Events [UIACheckBoxesChangedEvent];
6110                         if (eh != null)
6111                                 eh (this, EventArgs.Empty);
6112                 }
6113
6114                 private void OnUIAShowGroupsChanged ()
6115                 {
6116                         EventHandler eh = (EventHandler) Events [UIAShowGroupsChangedEvent];
6117                         if (eh != null)
6118                                 eh (this, EventArgs.Empty);
6119                 }
6120
6121                 private void OnUIAMultiSelectChanged ()
6122                 {
6123                         EventHandler eh = (EventHandler) Events [UIAMultiSelectChangedEvent];
6124                         if (eh != null)
6125                                 eh (this, EventArgs.Empty);
6126                 }
6127
6128                 private void OnUIALabelEditChanged ()
6129                 {
6130                         EventHandler eh = (EventHandler) Events [UIALabelEditChangedEvent];
6131                         if (eh != null)
6132                                 eh (this, EventArgs.Empty);
6133                 }
6134
6135                 private void OnUIAViewChanged ()
6136                 {
6137                         EventHandler eh = (EventHandler) Events [UIAViewChangedEvent];
6138                         if (eh != null)
6139                                 eh (this, EventArgs.Empty);
6140                 }
6141
6142                 internal void OnUIAFocusedItemChanged ()
6143                 {
6144                         EventHandler eh = (EventHandler) Events [UIAFocusedItemChangedEvent];
6145                         if (eh != null)
6146                                 eh (this, EventArgs.Empty);
6147                 }
6148
6149                 #endregion // UIA Framework: Methods, Properties and Events
6150
6151         }
6152 }