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 //
  28 // TODO:
  29 //   - Feedback for item activation, change in cursor types as mouse moves.
  30 //   - LabelEdit
  31 //   - Drag and drop
  32
  33
  34 // NOT COMPLETE
  35
  36
  37 using System.Collections;
  38 using System.ComponentModel;
  39 using System.ComponentModel.Design;
  40 using System.Drawing;
  41 using System.Runtime.InteropServices;
  42 using System.Globalization;
  43 #if NET_2_0
  44 using System.Collections.Generic;
  45 #endif
  46
  47 namespace System.Windows.Forms
  48 {
  49         [DefaultEvent ("SelectedIndexChanged")]
  50         [DefaultProperty ("Items")]
  51         [Designer ("System.Windows.Forms.Design.ListViewDesigner, " + Consts.AssemblySystem_Design, "System.ComponentModel.Design.IDesigner")]
  52 #if NET_2_0
  53         [ClassInterface (ClassInterfaceType.AutoDispatch)]
  54         [ComVisible (true)]
  55         [Docking (DockingBehavior.Ask)]
  56 #endif
  57         public class ListView : Control
  58         {
  59                 private ItemActivation activation = ItemActivation.Standard;
  60                 private ListViewAlignment alignment = ListViewAlignment.Top;
  61                 private bool allow_column_reorder = false;
  62                 private bool auto_arrange = true;
  63                 private bool check_boxes = false;
  64                 private readonly CheckedIndexCollection checked_indices;
  65                 private readonly CheckedListViewItemCollection checked_items;
  66                 private readonly ColumnHeaderCollection columns;
  67                 internal ListViewItem focused_item;
  68                 private bool full_row_select = false;
  69                 private bool grid_lines = false;
  70                 private ColumnHeaderStyle header_style = ColumnHeaderStyle.Clickable;
  71                 private bool hide_selection = true;
  72                 private bool hover_selection = false;
  73                 private IComparer item_sorter;
  74                 private readonly ListViewItemCollection items;
  75 #if NET_2_0
  76                 private readonly ListViewGroupCollection groups;
  77                 private bool show_groups = true;
  78 #endif
  79                 private bool label_edit = false;
  80                 private bool label_wrap = true;
  81                 private bool multiselect = true;
  82                 private bool scrollable = true;
  83                 private readonly SelectedIndexCollection selected_indices;
  84                 private readonly SelectedListViewItemCollection selected_items;
  85                 private SortOrder sort_order = SortOrder.None;
  86                 private ImageList state_image_list;
  87                 private bool updating = false;
  88                 private View view = View.LargeIcon;
  89                 private int layout_wd;    // We might draw more than our client area
  90                 private int layout_ht;    // therefore we need to have these two.
  91                 //private TextBox editor;   // Used for editing an item text
  92                 HeaderControl header_control;
  93                 internal ItemControl item_control;
  94                 internal ScrollBar h_scroll; // used for scrolling horizontally
  95                 internal ScrollBar v_scroll; // used for scrolling vertically
  96                 internal int h_marker;          // Position markers for scrolling
  97                 internal int v_marker;
  98                 private int keysearch_tickcnt;
  99                 private string keysearch_text;
 100                 static private readonly int keysearch_keydelay = 1000;
 101                 private int[] reordered_column_indices;
 102 #if NET_2_0
 103                 private Size tile_size;
 104 #endif
 105
 106                 // internal variables
 107                 internal ImageList large_image_list;
 108                 internal ImageList small_image_list;
 109                 internal Size text_size = Size.Empty;
 110
 111                 #region Events
 112                 static object AfterLabelEditEvent = new object ();
 113                 static object BeforeLabelEditEvent = new object ();
 114                 static object ColumnClickEvent = new object ();
 115                 static object ItemActivateEvent = new object ();
 116                 static object ItemCheckEvent = new object ();
 117                 static object ItemDragEvent = new object ();
 118                 static object SelectedIndexChangedEvent = new object ();
 119
 120                 public event LabelEditEventHandler AfterLabelEdit {
 121                         add { Events.AddHandler (AfterLabelEditEvent, value); }
 122                         remove { Events.RemoveHandler (AfterLabelEditEvent, value); }
 123                 }
 124
 125                 [Browsable (false)]
 126                 [EditorBrowsable (EditorBrowsableState.Never)]
 127                 public new event EventHandler BackgroundImageChanged {
 128                         add { base.BackgroundImageChanged += value; }
 129                         remove { base.BackgroundImageChanged -= value; }
 130                 }
 131
 132                 public event LabelEditEventHandler BeforeLabelEdit {
 133                         add { Events.AddHandler (BeforeLabelEditEvent, value); }
 134                         remove { Events.RemoveHandler (BeforeLabelEditEvent, value); }
 135                 }
 136
 137                 public event ColumnClickEventHandler ColumnClick {
 138                         add { Events.AddHandler (ColumnClickEvent, value); }
 139                         remove { Events.RemoveHandler (ColumnClickEvent, value); }
 140                 }
 141
 142                 public event EventHandler ItemActivate {
 143                         add { Events.AddHandler (ItemActivateEvent, value); }
 144                         remove { Events.RemoveHandler (ItemActivateEvent, value); }
 145                 }
 146
 147                 public event ItemCheckEventHandler ItemCheck {
 148                         add { Events.AddHandler (ItemCheckEvent, value); }
 149                         remove { Events.RemoveHandler (ItemCheckEvent, value); }
 150                 }
 151
 152                 public event ItemDragEventHandler ItemDrag {
 153                         add { Events.AddHandler (ItemDragEvent, value); }
 154                         remove { Events.RemoveHandler (ItemDragEvent, value); }
 155                 }
 156
 157                 [Browsable (false)]
 158                 [EditorBrowsable (EditorBrowsableState.Never)]
 159                 public new event PaintEventHandler Paint {
 160                         add { base.Paint += value; }
 161                         remove { base.Paint -= value; }
 162                 }
 163
 164                 public event EventHandler SelectedIndexChanged {
 165                         add { Events.AddHandler (SelectedIndexChangedEvent, value); }
 166                         remove { Events.RemoveHandler (SelectedIndexChangedEvent, value); }
 167                 }
 168
 169                 [Browsable (false)]
 170                 [EditorBrowsable (EditorBrowsableState.Never)]
 171                 public new event EventHandler TextChanged {
 172                         add { base.TextChanged += value; }
 173                         remove { base.TextChanged -= value; }
 174                 }
 175
 176                 #endregion // Events
 177
 178                 #region Public Constructors
 179                 public ListView ()
 180                 {
 181                         background_color = ThemeEngine.Current.ColorWindow;
 182                         items = new ListViewItemCollection (this);
 183 #if NET_2_0
 184                         groups = new ListViewGroupCollection (this);
 185 #endif
 186                         checked_indices = new CheckedIndexCollection (this);
 187                         checked_items = new CheckedListViewItemCollection (this);
 188                         columns = new ColumnHeaderCollection (this);
 189                         foreground_color = SystemColors.WindowText;
 190                         selected_indices = new SelectedIndexCollection (this);
 191                         selected_items = new SelectedListViewItemCollection (this);
 192
 193                         border_style = BorderStyle.Fixed3D;
 194
 195                         header_control = new HeaderControl (this);
 196                         header_control.Visible = false;
 197                         Controls.AddImplicit (header_control);
 198
 199                         item_control = new ItemControl (this);
 200                         Controls.AddImplicit (item_control);
 201
 202                         h_scroll = new ImplicitHScrollBar ();
 203                         Controls.AddImplicit (this.h_scroll);
 204
 205                         v_scroll = new ImplicitVScrollBar ();
 206                         Controls.AddImplicit (this.v_scroll);
 207
 208                         h_marker = v_marker = 0;
 209                         keysearch_tickcnt = 0;
 210
 211                         // scroll bars are disabled initially
 212                         h_scroll.Visible = false;
 213                         h_scroll.ValueChanged += new EventHandler(HorizontalScroller);
 214                         v_scroll.Visible = false;
 215                         v_scroll.ValueChanged += new EventHandler(VerticalScroller);
 216
 217                         // event handlers
 218                         base.KeyDown += new KeyEventHandler(ListView_KeyDown);
 219                         SizeChanged += new EventHandler (ListView_SizeChanged);
 220                         GotFocus += new EventHandler (FocusChanged);
 221                         LostFocus += new EventHandler (FocusChanged);
 222                         MouseWheel += new MouseEventHandler(ListView_MouseWheel);
 223
 224                         this.SetStyle (ControlStyles.UserPaint | ControlStyles.StandardClick
 225 #if NET_2_0
 226                                 | ControlStyles.UseTextForAccessibility
 227 #endif
 228                                 , false);
 229                 }
 230                 #endregion      // Public Constructors
 231
 232                 #region Private Internal Properties
 233                 internal Size CheckBoxSize {
 234                         get {
 235                                 if (this.check_boxes) {
 236                                         if (this.state_image_list != null)
 237                                                 return this.state_image_list.ImageSize;
 238                                         else
 239                                                 return ThemeEngine.Current.ListViewCheckBoxSize;
 240                                 }
 241                                 return Size.Empty;
 242                         }
 243                 }
 244
 245                 #endregion      // Private Internal Properties
 246
 247                 #region  Protected Properties
 248                 protected override CreateParams CreateParams {
 249                         get { return base.CreateParams; }
 250                 }
 251
 252                 protected override Size DefaultSize {
 253                         get { return ThemeEngine.Current.ListViewDefaultSize; }
 254                 }
 255                 #endregion      // Protected Properties
 256
 257                 #region Public Instance Properties
 258                 [DefaultValue (ItemActivation.Standard)]
 259                 public ItemActivation Activation {
 260                         get { return activation; }
 261                         set {
 262                                 if (value != ItemActivation.Standard && value != ItemActivation.OneClick &&
 263                                         value != ItemActivation.TwoClick) {
 264                                         throw new InvalidEnumArgumentException (string.Format
 265                                                 ("Enum argument value '{0}' is not valid for Activation", value));
 266                                 }
 267
 268                                 activation = value;
 269                         }
 270                 }
 271
 272                 [DefaultValue (ListViewAlignment.Top)]
 273                 [Localizable (true)]
 274                 public ListViewAlignment Alignment {
 275                         get { return alignment; }
 276                         set {
 277                                 if (value != ListViewAlignment.Default && value != ListViewAlignment.Left &&
 278                                         value != ListViewAlignment.SnapToGrid && value != ListViewAlignment.Top) {
 279                                         throw new InvalidEnumArgumentException (string.Format
 280                                                 ("Enum argument value '{0}' is not valid for Alignment", value));
 281                                 }
 282
 283                                 if (this.alignment != value) {
 284                                         alignment = value;
 285                                         // alignment does not matter in Details/List views
 286                                         if (this.view == View.LargeIcon ||
 287                                             this.View == View.SmallIcon)
 288                                                 this.Redraw (true);
 289                                 }
 290                         }
 291                 }
 292
 293                 [DefaultValue (false)]
 294                 public bool AllowColumnReorder {
 295                         get { return allow_column_reorder; }
 296                         set { allow_column_reorder = value; }
 297                 }
 298
 299                 [DefaultValue (true)]
 300                 public bool AutoArrange {
 301                         get { return auto_arrange; }
 302                         set {
 303                                 if (auto_arrange != value) {
 304                                         auto_arrange = value;
 305                                         // autoarrange does not matter in Details/List views
 306                                         if (this.view == View.LargeIcon || this.View == View.SmallIcon)
 307                                                 this.Redraw (true);
 308                                 }
 309                         }
 310                 }
 311
 312                 public override Color BackColor {
 313                         get {
 314                                 if (background_color.IsEmpty)
 315                                         return ThemeEngine.Current.ColorWindow;
 316                                 else
 317                                         return background_color;
 318                         }
 319                         set { background_color = value; }
 320                 }
 321
 322                 [Browsable (false)]
 323                 [EditorBrowsable (EditorBrowsableState.Never)]
 324                 public override Image BackgroundImage {
 325                         get { return base.BackgroundImage; }
 326                         set { base.BackgroundImage = value; }
 327                 }
 328
 329                 [DefaultValue (BorderStyle.Fixed3D)]
 330                 [DispId (-504)]
 331                 public BorderStyle BorderStyle {
 332                         get { return InternalBorderStyle; }
 333                         set { InternalBorderStyle = value; }
 334                 }
 335
 336                 [DefaultValue (false)]
 337                 public bool CheckBoxes {
 338                         get { return check_boxes; }
 339                         set {
 340                                 if (check_boxes != value) {
 341 #if NET_2_0
 342                                         if (value && View == View.Tile)
 343                                                 throw new NotSupportedException ("CheckBoxes are not"
 344                                                         + " supported in Tile view. Choose a different"
 345                                                         + " view or set CheckBoxes to false.");
 346 #endif
 347
 348                                         check_boxes = value;
 349                                         this.Redraw (true);
 350                                 }
 351                         }
 352                 }
 353
 354                 [Browsable (false)]
 355                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 356                 public CheckedIndexCollection CheckedIndices {
 357                         get { return checked_indices; }
 358                 }
 359
 360                 [Browsable (false)]
 361                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 362                 public CheckedListViewItemCollection CheckedItems {
 363                         get { return checked_items; }
 364                 }
 365
 366                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]
 367                 [Localizable (true)]
 368                 [MergableProperty (false)]
 369                 public ColumnHeaderCollection Columns {
 370                         get { return columns; }
 371                 }
 372
 373                 [Browsable (false)]
 374                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 375                 public ListViewItem FocusedItem {
 376                         get {
 377                                 return focused_item;
 378                         }
 379                 }
 380
 381                 public override Color ForeColor {
 382                         get {
 383                                 if (foreground_color.IsEmpty)
 384                                         return ThemeEngine.Current.ColorWindowText;
 385                                 else
 386                                         return foreground_color;
 387                         }
 388                         set { foreground_color = value; }
 389                 }
 390
 391                 [DefaultValue (false)]
 392                 public bool FullRowSelect {
 393                         get { return full_row_select; }
 394                         set { full_row_select = value; }
 395                 }
 396
 397                 [DefaultValue (false)]
 398                 public bool GridLines {
 399                         get { return grid_lines; }
 400                         set {
 401                                 if (grid_lines != value) {
 402                                         grid_lines = value;
 403                                         this.Redraw (false);
 404                                 }
 405                         }
 406                 }
 407
 408                 [DefaultValue (ColumnHeaderStyle.Clickable)]
 409                 public ColumnHeaderStyle HeaderStyle {
 410                         get { return header_style; }
 411                         set {
 412                                 if (header_style == value)
 413                                         return;
 414
 415                                 switch (value) {
 416                                 case ColumnHeaderStyle.Clickable:
 417                                 case ColumnHeaderStyle.Nonclickable:
 418                                 case ColumnHeaderStyle.None:
 419                                         break;
 420                                 default:
 421                                         throw new InvalidEnumArgumentException (string.Format
 422                                                 ("Enum argument value '{0}' is not valid for ColumnHeaderStyle", value));
 423                                 }
 424
 425                                 header_style = value;
 426                                 if (view == View.Details)
 427                                         Redraw (true);
 428                         }
 429                 }
 430
 431                 [DefaultValue (true)]
 432                 public bool HideSelection {
 433                         get { return hide_selection; }
 434                         set {
 435                                 if (hide_selection != value) {
 436                                         hide_selection = value;
 437                                         this.Redraw (false);
 438                                 }
 439                         }
 440                 }
 441
 442                 [DefaultValue (false)]
 443                 public bool HoverSelection {
 444                         get { return hover_selection; }
 445                         set { hover_selection = value; }
 446                 }
 447
 448                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]
 449                 [Localizable (true)]
 450                 [MergableProperty (false)]
 451                 public ListViewItemCollection Items {
 452                         get { return items; }
 453                 }
 454
 455                 [DefaultValue (false)]
 456                 public bool LabelEdit {
 457                         get { return label_edit; }
 458                         set { label_edit = value; }
 459                 }
 460
 461                 [DefaultValue (true)]
 462                 [Localizable (true)]
 463                 public bool LabelWrap {
 464                         get { return label_wrap; }
 465                         set {
 466                                 if (label_wrap != value) {
 467                                         label_wrap = value;
 468                                         this.Redraw (true);
 469                                 }
 470                         }
 471                 }
 472
 473                 [DefaultValue (null)]
 474                 public ImageList LargeImageList {
 475                         get { return large_image_list; }
 476                         set {
 477                                 large_image_list = value;
 478                                 this.Redraw (true);
 479                         }
 480                 }
 481
 482                 [Browsable (false)]
 483                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 484                 public IComparer ListViewItemSorter {
 485                         get {
 486                                 if (View != View.SmallIcon && View != View.LargeIcon && item_sorter is ItemComparer)
 487                                         return null;
 488                                 return item_sorter;
 489                         }
 490                         set {
 491                                 if (item_sorter != value) {
 492                                         item_sorter = value;
 493                                         Sort ();
 494                                 }
 495                         }
 496                 }
 497
 498                 [DefaultValue (true)]
 499                 public bool MultiSelect {
 500                         get { return multiselect; }
 501                         set { multiselect = value; }
 502                 }
 503
 504                 [DefaultValue (true)]
 505                 public bool Scrollable {
 506                         get { return scrollable; }
 507                         set {
 508                                 if (scrollable != value) {
 509                                         scrollable = value;
 510                                         this.Redraw (true);
 511                                 }
 512                         }
 513                 }
 514
 515                 [Browsable (false)]
 516                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 517                 public SelectedIndexCollection SelectedIndices {
 518                         get { return selected_indices; }
 519                 }
 520
 521                 [Browsable (false)]
 522                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 523                 public SelectedListViewItemCollection SelectedItems {
 524                         get { return selected_items; }
 525                 }
 526
 527 #if NET_2_0
 528                 [DefaultValue(true)]
 529                 public bool ShowGroups {
 530                         get { return show_groups; }
 531                         set
 532                         {
 533                                 if (show_groups != value)
 534                                 {
 535                                         show_groups = value;
 536                                         Redraw(true);
 537                                 }
 538                         }
 539                 }
 540
 541                 [LocalizableAttribute(true)]
 542                 public ListViewGroupCollection Groups {
 543                         get { return groups;    }
 544                 }
 545 #endif
 546
 547                 [DefaultValue (null)]
 548                 public ImageList SmallImageList {
 549                         get { return small_image_list; }
 550                         set {
 551                                 small_image_list = value;
 552                                 this.Redraw (true);
 553                         }
 554                 }
 555
 556                 [DefaultValue (SortOrder.None)]
 557                 public SortOrder Sorting {
 558                         get { return sort_order; }
 559                         set {
 560                                 if (!Enum.IsDefined (typeof (SortOrder), value)) {
 561                                         throw new InvalidEnumArgumentException ("value", (int) value,
 562                                                 typeof (SortOrder));
 563                                 }
 564
 565                                 if (sort_order == value)
 566                                         return;
 567
 568                                 sort_order = value;
 569
 570                                 if (value == SortOrder.None) {
 571                                         if (item_sorter != null) {
 572                                                 // ListViewItemSorter should never be reset for SmallIcon
 573                                                 // and LargeIcon view
 574                                                 if (View != View.SmallIcon && View != View.LargeIcon)
 575 #if NET_2_0
 576                                                         item_sorter = null;
 577 #else
 578                                                         // in .NET 1.1, only internal IComparer would be
 579                                                         // set to null
 580                                                         if (item_sorter is ItemComparer)
 581                                                                 item_sorter = null;
 582 #endif
 583                                         }
 584                                         this.Redraw (false);
 585                                 } else {
 586                                         if (item_sorter == null)
 587                                                 item_sorter = new ItemComparer (value);
 588                                         if (item_sorter is ItemComparer) {
 589 #if NET_2_0
 590                                                 item_sorter = new ItemComparer (value);
 591 #else
 592                                                 // in .NET 1.1, the sort order is not updated for
 593                                                 // SmallIcon and LargeIcon views if no custom IComparer
 594                                                 // is set
 595                                                 if (View != View.SmallIcon && View != View.LargeIcon)
 596                                                         item_sorter = new ItemComparer (value);
 597 #endif
 598                                         }
 599                                         Sort ();
 600                                 }
 601                         }
 602                 }
 603
 604                 [DefaultValue (null)]
 605                 public ImageList StateImageList {
 606                         get { return state_image_list; }
 607                         set {
 608                                 state_image_list = value;
 609                                 this.Redraw (true);
 610                         }
 611                 }
 612
 613                 [Bindable (false)]
 614                 [Browsable (false)]
 615                 [EditorBrowsable (EditorBrowsableState.Never)]
 616                 public override string Text {
 617                         get { return base.Text; }
 618                         set {
 619                                 if (value == base.Text)
 620                                         return;
 621
 622                                 base.Text = value;
 623                                 this.Redraw (true);
 624                         }
 625                 }
 626
 627 #if NET_2_0
 628                 public Size TileSize {
 629                         get {
 630                                 return tile_size;
 631                         }
 632                         set {
 633                                 if (value.Width <= 0 || value.Height <= 0)
 634                                         throw new ArgumentOutOfRangeException ("value");
 635
 636                                 tile_size = value;
 637                                 Redraw (true);
 638                         }
 639                 }
 640 #endif
 641
 642                 [Browsable (false)]
 643                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 644                 public ListViewItem TopItem {
 645                         get {
 646                                 // there is no item
 647                                 if (this.items.Count == 0)
 648                                         return null;
 649                                 // if contents are not scrolled
 650                                 // it is the first item
 651                                 else if (h_marker == 0 && v_marker == 0)
 652                                         return this.items [0];
 653                                 // do a hit test for the scrolled position
 654                                 else {
 655                                         foreach (ListViewItem item in this.items) {
 656                                                 if (item.Bounds.X >= 0 && item.Bounds.Y >= 0)
 657                                                         return item;
 658                                         }
 659                                         return null;
 660                                 }
 661                         }
 662                 }
 663
 664 #if NET_2_0
 665                 [MonoTODO("Implement")]
 666                 public bool UseCompatibleStateImageBehavior {
 667                         get {
 668                                 return false;
 669                         }
 670
 671                         set {
 672                         }
 673                 }
 674 #endif
 675
 676                 [DefaultValue (View.LargeIcon)]
 677                 public View View {
 678                         get { return view; }
 679                         set {
 680                                 if (!Enum.IsDefined (typeof (View), value))
 681                                         throw new InvalidEnumArgumentException ("value", (int) value,
 682                                                 typeof (View));
 683
 684                                 if (view != value) {
 685 #if NET_2_0
 686                                         if (CheckBoxes && value == View.Tile)
 687                                                 throw new NotSupportedException ("CheckBoxes are not"
 688                                                         + " supported in Tile view. Choose a different"
 689                                                         + " view or set CheckBoxes to false.");
 690 #endif
 691
 692                                         h_scroll.Value = v_scroll.Value = 0;
 693                                         view = value;
 694                                         Redraw (true);
 695                                 }
 696                         }
 697                 }
 698                 #endregion      // Public Instance Properties
 699
 700                 #region Internal Methods Properties
 701
 702                 internal int FirstVisibleIndex {
 703                         get {
 704                                 // there is no item
 705                                 if (this.items.Count == 0)
 706                                         return 0;
 707
 708                                 if (h_marker == 0 && v_marker == 0)
 709                                         return 0;
 710
 711                                 foreach (ListViewItem item in this.items) {
 712                                         if (item.Bounds.Right >= 0 && item.Bounds.Bottom >= 0)
 713                                                 return item.Index;
 714                                 }
 715                                 return 0;
 716
 717                         }
 718                 }
 719
 720
 721                 internal int LastVisibleIndex {
 722                         get {
 723                                 for (int i = FirstVisibleIndex; i < Items.Count; i++) {
 724                                         if (View == View.List || Alignment == ListViewAlignment.Left) {
 725                                                 if (Items[i].Bounds.X > item_control.ClientRectangle.Right)
 726                                                         return i - 1;
 727                                         } else {
 728                                                 if (Items[i].Bounds.Y > item_control.ClientRectangle.Bottom)
 729                                                         return i - 1;
 730                                         }
 731                                 }
 732
 733                                 return Items.Count - 1;
 734                         }
 735                 }
 736
 737                 internal void OnSelectedIndexChanged ()
 738                 {
 739                         if (IsHandleCreated)
 740                                 OnSelectedIndexChanged (EventArgs.Empty);
 741                 }
 742
 743                 internal int TotalWidth {
 744                         get { return Math.Max (this.Width, this.layout_wd); }
 745                 }
 746
 747                 internal int TotalHeight {
 748                         get { return Math.Max (this.Height, this.layout_ht); }
 749                 }
 750
 751                 internal void Redraw (bool recalculate)
 752                 {
 753                         // Avoid calculations when control is being updated
 754                         if (this.updating)
 755                                 return;
 756
 757                         if (recalculate)
 758                                 CalculateListView (this.alignment);
 759
 760                         Refresh ();
 761                 }
 762
 763                 const int text_padding = 5;
 764
 765                 internal Size GetChildColumnSize (int index)
 766                 {
 767                         Size ret_size = Size.Empty;
 768                         ColumnHeader col = this.columns [index];
 769
 770                         if (col.Width == -2) { // autosize = max(items, columnheader)
 771                                 Size size = Size.Ceiling (this.DeviceContext.MeasureString
 772                                                           (col.Text, this.Font));
 773                                 size.Width += text_padding;
 774                                 ret_size = BiggestItem (index);
 775                                 if (size.Width > ret_size.Width)
 776                                         ret_size = size;
 777                         }
 778                         else { // -1 and all the values < -2 are put under one category
 779                                 ret_size = BiggestItem (index);
 780                                 // fall back to empty columns' width if no subitem is available for a column
 781                                 if (ret_size.IsEmpty) {
 782                                         ret_size.Width = ThemeEngine.Current.ListViewEmptyColumnWidth;
 783                                         if (col.Text.Length > 0)
 784                                                 ret_size.Height = Size.Ceiling (this.DeviceContext.MeasureString
 785                                                                                 (col.Text, this.Font)).Height;
 786                                         else
 787                                                 ret_size.Height = this.Font.Height;
 788                                 }
 789                         }
 790
 791                         ret_size.Height += text_padding;
 792
 793                         // adjust the size for icon and checkbox for 0th column
 794                         if (index == 0) {
 795                                 ret_size.Width += (this.CheckBoxSize.Width + 4);
 796                                 if (this.small_image_list != null)
 797                                         ret_size.Width += this.small_image_list.ImageSize.Width;
 798                         }
 799                         return ret_size;
 800                 }
 801
 802                 // Returns the size of biggest item text in a column.
 803                 private Size BiggestItem (int col)
 804                 {
 805                         Size temp = Size.Empty;
 806                         Size ret_size = Size.Empty;
 807
 808                         // 0th column holds the item text, we check the size of
 809                         // the various subitems falling in that column and get
 810                         // the biggest one's size.
 811                         foreach (ListViewItem item in items) {
 812                                 if (col >= item.SubItems.Count)
 813                                         continue;
 814
 815                                 temp = Size.Ceiling (this.DeviceContext.MeasureString
 816                                                      (item.SubItems [col].Text, this.Font));
 817                                 if (temp.Width > ret_size.Width)
 818                                         ret_size = temp;
 819                         }
 820
 821                         // adjustment for space
 822                         if (!ret_size.IsEmpty)
 823                                 ret_size.Width += 4;
 824
 825                         return ret_size;
 826                 }
 827
 828                 const int max_wrap_padding = 38;
 829
 830                 // Sets the size of the biggest item text as per the view
 831                 private void CalcTextSize ()
 832                 {
 833                         // clear the old value
 834                         text_size = Size.Empty;
 835
 836                         if (items.Count == 0)
 837                                 return;
 838
 839                         text_size = BiggestItem (0);
 840
 841                         if (view == View.LargeIcon && this.label_wrap) {
 842                                 Size temp = Size.Empty;
 843                                 if (this.check_boxes)
 844                                         temp.Width += 2 * this.CheckBoxSize.Width;
 845                                 int icon_w = LargeImageList == null ? 12 : LargeImageList.ImageSize.Width;
 846                                 temp.Width += icon_w + max_wrap_padding;
 847                                 // wrapping is done for two lines only
 848                                 if (text_size.Width > temp.Width) {
 849                                         text_size.Width = temp.Width;
 850                                         text_size.Height *= 2;
 851                                 }
 852                         }
 853                         else if (view == View.List) {
 854                                 // in list view max text shown in determined by the
 855                                 // control width, even if scolling is enabled.
 856                                 int max_wd = this.Width - (this.CheckBoxSize.Width - 2);
 857                                 if (this.small_image_list != null)
 858                                         max_wd -= this.small_image_list.ImageSize.Width;
 859
 860                                 if (text_size.Width > max_wd)
 861                                         text_size.Width = max_wd;
 862                         }
 863
 864                         // we do the default settings, if we have got 0's
 865                         if (text_size.Height <= 0)
 866                                 text_size.Height = this.Font.Height;
 867                         if (text_size.Width <= 0)
 868                                 text_size.Width = this.Width;
 869
 870                         // little adjustment
 871                         text_size.Width += 4;
 872                         text_size.Height += 2;
 873                 }
 874
 875                 private void Scroll (ScrollBar scrollbar, int delta)
 876                 {
 877                         if (delta == 0 || !scrollbar.Visible)
 878                                 return;
 879
 880                         int max;
 881                         if (scrollbar == h_scroll)
 882                                 max = h_scroll.Maximum - item_control.Width;
 883                         else
 884                                 max = v_scroll.Maximum - item_control.Height;
 885
 886                         int val = scrollbar.Value + delta;
 887                         if (val > max)
 888                                 val = max;
 889                         else if (val < scrollbar.Minimum)
 890                                 val = scrollbar.Minimum;
 891                         scrollbar.Value = val;
 892                 }
 893
 894                 private void CalculateScrollBars ()
 895                 {
 896                         Rectangle client_area = ClientRectangle;
 897
 898                         if (!this.scrollable || this.items.Count <= 0) {
 899                                 h_scroll.Visible = false;
 900                                 v_scroll.Visible = false;
 901                                 item_control.Location = new Point (0, header_control.Height);
 902                                 item_control.Height = ClientRectangle.Width - header_control.Height;
 903                                 item_control.Width = ClientRectangle.Width;
 904                                 header_control.Width = ClientRectangle.Width;
 905                                 return;
 906                         }
 907
 908                         // Don't calculate if the view is not displayable
 909                         if (client_area.Height < 0 || client_area.Width < 0)
 910                                 return;
 911
 912                         // making a scroll bar visible might make
 913                         // other scroll bar visible
 914                         if (layout_wd > client_area.Right) {
 915                                 h_scroll.Visible = true;
 916                                 if ((layout_ht + h_scroll.Height) > client_area.Bottom)
 917                                         v_scroll.Visible = true;
 918                                 else
 919                                         v_scroll.Visible = false;
 920                         } else if (layout_ht > client_area.Bottom) {
 921                                 v_scroll.Visible = true;
 922                                 if ((layout_wd + v_scroll.Width) > client_area.Right)
 923                                         h_scroll.Visible = true;
 924                                 else
 925                                         h_scroll.Visible = false;
 926                         } else {
 927                                 h_scroll.Visible = false;
 928                                 v_scroll.Visible = false;
 929                         }
 930
 931                         item_control.Height = ClientRectangle.Height - header_control.Height;
 932
 933                         if (h_scroll.is_visible) {
 934                                 h_scroll.Location = new Point (client_area.X, client_area.Bottom - h_scroll.Height);
 935                                 h_scroll.Minimum = 0;
 936
 937                                 // if v_scroll is visible, adjust the maximum of the
 938                                 // h_scroll to account for the width of v_scroll
 939                                 if (v_scroll.Visible) {
 940                                         h_scroll.Maximum = layout_wd + v_scroll.Width;
 941                                         h_scroll.Width = client_area.Width - v_scroll.Width;
 942                                 }
 943                                 else {
 944                                         h_scroll.Maximum = layout_wd;
 945                                         h_scroll.Width = client_area.Width;
 946                                 }
 947
 948                                 h_scroll.LargeChange = client_area.Width;
 949                                 h_scroll.SmallChange = Font.Height;
 950                                 item_control.Height -= h_scroll.Height;
 951                         }
 952
 953                         if (header_control.is_visible)
 954                                 header_control.Width = ClientRectangle.Width;
 955                         item_control.Width = ClientRectangle.Width;
 956
 957                         if (v_scroll.is_visible) {
 958                                 v_scroll.Location = new Point (client_area.Right - v_scroll.Width, client_area.Y);
 959                                 v_scroll.Minimum = 0;
 960
 961                                 // if h_scroll is visible, adjust the maximum of the
 962                                 // v_scroll to account for the height of h_scroll
 963                                 if (h_scroll.Visible) {
 964                                         v_scroll.Maximum = layout_ht + h_scroll.Height;
 965                                         v_scroll.Height = client_area.Height; // - h_scroll.Height already done
 966                                 } else {
 967                                         v_scroll.Maximum = layout_ht;
 968                                         v_scroll.Height = client_area.Height;
 969                                 }
 970
 971                                 v_scroll.LargeChange = client_area.Height;
 972                                 v_scroll.SmallChange = Font.Height;
 973                                 if (header_control.Visible)
 974                                         header_control.Width -= v_scroll.Width;
 975                                 item_control.Width -= v_scroll.Width;
 976                         }
 977                 }
 978
 979 #if NET_2_0
 980                 internal int GetReorderedColumnIndex (ColumnHeader column)
 981                 {
 982                         if (reordered_column_indices == null)
 983                                 return column.Index;
 984
 985                         for (int i = 0; i < Columns.Count; i++)
 986                                 if (reordered_column_indices [i] == column.Index)
 987                                         return i;
 988
 989                         return -1;
 990                 }
 991 #endif
 992
 993                 ColumnHeader GetReorderedColumn (int index)
 994                 {
 995                         if (reordered_column_indices == null)
 996                                 return Columns [index];
 997                         else
 998                                 return Columns [reordered_column_indices [index]];
 999                 }
1000
1001                 internal void ReorderColumn (ColumnHeader col, int index)
1002                 {
1003 #if NET_2_0
1004                         ColumnReorderedEventHandler eh = (ColumnReorderedEventHandler) (Events [ColumnReorderedEvent]);
1005                         if (eh != null){
1006                                 ColumnReorderedEventArgs args = new ColumnReorderedEventArgs (col.Index, index, col);
1007
1008                                 eh (this, args);
1009                                 if (args.Cancel){
1010                                         header_control.Invalidate ();
1011                                         item_control.Invalidate ();
1012                                         return;
1013                                 }
1014                         }
1015 #endif
1016                         if (reordered_column_indices == null) {
1017                                 reordered_column_indices = new int [Columns.Count];
1018                                 for (int i = 0; i < Columns.Count; i++)
1019                                         reordered_column_indices [i] = i;
1020                         }
1021
1022                         if (reordered_column_indices [index] == col.Index)
1023                                 return;
1024
1025                         int[] curr = reordered_column_indices;
1026                         int[] result = new int [Columns.Count];
1027                         int curr_idx = 0;
1028                         for (int i = 0; i < Columns.Count; i++) {
1029                                 if (curr_idx < Columns.Count && curr [curr_idx] == col.Index)
1030                                         curr_idx++;
1031
1032                                 if (i == index)
1033                                         result [i] = col.Index;
1034                                 else
1035                                         result [i] = curr [curr_idx++];
1036                         }
1037
1038                         reordered_column_indices = result;
1039                         LayoutDetails ();
1040                         header_control.Invalidate ();
1041                         item_control.Invalidate ();
1042                 }
1043
1044                 Size LargeIconItemSize {
1045                         get {
1046                                 int image_w = LargeImageList == null ? 12 : LargeImageList.ImageSize.Width;
1047                                 int image_h = LargeImageList == null ? 2 : LargeImageList.ImageSize.Height;
1048                                 int w = CheckBoxSize.Width + 2 + Math.Max (text_size.Width, image_w);
1049                                 int h = text_size.Height + 2 + Math.Max (CheckBoxSize.Height, image_h);
1050                                 return new Size (w, h);
1051                         }
1052                 }
1053
1054                 Size SmallIconItemSize {
1055                         get {
1056                                 int image_w = SmallImageList == null ? 0 : SmallImageList.ImageSize.Width;
1057                                 int image_h = SmallImageList == null ? 0 : SmallImageList.ImageSize.Height;
1058                                 int w = text_size.Width + 2 + CheckBoxSize.Width + image_w;
1059                                 int h = Math.Max (text_size.Height, Math.Max (CheckBoxSize.Height, image_h));
1060                                 return new Size (w, h);
1061                         }
1062                 }
1063
1064 #if NET_2_0
1065                 Size TileItemSize {
1066                         get {
1067                                 // Calculate tile size if needed
1068                                 // It appears that using Font.Size instead of a SizeF value can give us
1069                                 // a slightly better approach to the proportions defined in .Net
1070                                 if (tile_size == Size.Empty) {
1071                                         int image_w = LargeImageList == null ? 0 : LargeImageList.ImageSize.Width;
1072                                         int image_h = LargeImageList == null ? 0 : LargeImageList.ImageSize.Height;
1073                                         int w = (int)Font.Size * ThemeEngine.Current.ListViewTileWidthFactor + image_w + 4;
1074                                         int h = Math.Max ((int)Font.Size * ThemeEngine.Current.ListViewTileHeightFactor, image_h);
1075
1076                                         tile_size = new Size (w, h);
1077                                 }
1078
1079                                 return tile_size;
1080                         }
1081                 }
1082 #endif
1083
1084                 int rows;
1085                 int cols;
1086                 ListViewItem[,] item_matrix;
1087
1088                 void LayoutIcons (Size item_size, bool left_aligned, int x_spacing, int y_spacing)
1089                 {
1090                         header_control.Visible = false;
1091                         header_control.Size = Size.Empty;
1092                         item_control.Visible = true;
1093                         item_control.Location = Point.Empty;
1094
1095                         if (items.Count == 0)
1096                                 return;
1097
1098                         Size sz = item_size;
1099                         Rectangle area = ClientRectangle;
1100
1101                         if (left_aligned) {
1102                                 rows = (int) Math.Floor ((double)(area.Height - h_scroll.Height + y_spacing) / (double)(sz.Height + y_spacing));
1103                                 if (rows <= 0)
1104                                         rows = 1;
1105                                 cols = (int) Math.Ceiling ((double)items.Count / (double)rows);
1106                         } else {
1107                                 cols = (int) Math.Floor ((double)(area.Width - v_scroll.Width + x_spacing) / (double)(sz.Width + x_spacing));
1108                                 if (cols <= 0)
1109                                         cols = 1;
1110                                 rows = (int) Math.Ceiling ((double)items.Count / (double)cols);
1111                         }
1112
1113                         layout_ht = rows * (sz.Height + y_spacing) - y_spacing;
1114                         layout_wd = cols * (sz.Width + x_spacing) - x_spacing;
1115                         item_matrix = new ListViewItem [rows, cols];
1116                         int row = 0;
1117                         int col = 0;
1118                         foreach (ListViewItem item in items) {
1119                                 int x = col * (sz.Width + x_spacing);
1120                                 int y = row * (sz.Height + y_spacing);
1121                                 item.Location = new Point (x, y);
1122                                 item.Layout ();
1123                                 item.row = row;
1124                                 item.col = col;
1125                                 item_matrix [row, col] = item;
1126                                 if (left_aligned) {
1127                                         if (++row == rows) {
1128                                                 row = 0;
1129                                                 col++;
1130                                         }
1131                                 } else {
1132                                         if (++col == cols) {
1133                                                 col = 0;
1134                                                 row++;
1135                                         }
1136                                 }
1137                         }
1138
1139                         item_control.Size = new Size (layout_wd, layout_ht);
1140                 }
1141
1142                 void LayoutHeader ()
1143                 {
1144                         int x = 0;
1145                         for (int i = 0; i < Columns.Count; i++) {
1146                                 ColumnHeader col = GetReorderedColumn (i);
1147                                 col.X = x;
1148                                 col.Y = 0;
1149                                 col.CalcColumnHeader ();
1150                                 x += col.Wd;
1151                         }
1152
1153                         if (x < ClientRectangle.Width)
1154                                 x = ClientRectangle.Width;
1155
1156                         if (header_style == ColumnHeaderStyle.None) {
1157                                 header_control.Visible = false;
1158                                 header_control.Size = Size.Empty;
1159                         } else {
1160                                 header_control.Width = x;
1161                                 header_control.Height = columns [0].Ht;
1162                                 header_control.Visible = true;
1163                         }
1164                 }
1165
1166                 void LayoutDetails ()
1167                 {
1168                         if (columns.Count == 0) {
1169                                 header_control.Visible = false;
1170                                 item_control.Visible = false;
1171                                 return;
1172                         }
1173
1174                         LayoutHeader ();
1175
1176                         item_control.Visible = true;
1177                         item_control.Location = new Point (0, header_control.Height);
1178
1179                         int y = 0;
1180                         if (items.Count > 0) {
1181                                 foreach (ListViewItem item in items) {
1182                                         item.Layout ();
1183                                         item.Location = new Point (0, y);
1184                                         y += item.Bounds.Height + 2;
1185                                 }
1186
1187                                 // some space for bottom gridline
1188                                 if (grid_lines)
1189                                         y += 2;
1190                         }
1191
1192                         layout_wd = Math.Max (header_control.Width, item_control.Width);
1193                         layout_ht = y + header_control.Height;
1194                 }
1195
1196                 private void CalculateListView (ListViewAlignment align)
1197                 {
1198                         CalcTextSize ();
1199
1200                         switch (view) {
1201                         case View.Details:
1202                                 LayoutDetails ();
1203                                 break;
1204
1205                         case View.SmallIcon:
1206                                 LayoutIcons (SmallIconItemSize, alignment == ListViewAlignment.Left, 4, 2);
1207                                 break;
1208
1209                         case View.LargeIcon:
1210                                 LayoutIcons (LargeIconItemSize, alignment == ListViewAlignment.Left,
1211                                              ThemeEngine.Current.ListViewHorizontalSpacing,
1212                                              ThemeEngine.Current.ListViewVerticalSpacing);
1213                                 break;
1214
1215                         case View.List:
1216                                 LayoutIcons (SmallIconItemSize, true, 4, 2);
1217                                 break;
1218 #if NET_2_0
1219                         case View.Tile:
1220                                 LayoutIcons (TileItemSize, alignment == ListViewAlignment.Left,
1221                                                 ThemeEngine.Current.ListViewHorizontalSpacing,
1222                                                 ThemeEngine.Current.ListViewVerticalSpacing);
1223                                 break;
1224 #endif
1225                         }
1226
1227                         CalculateScrollBars ();
1228                 }
1229
1230                 private bool KeySearchString (KeyEventArgs ke)
1231                 {
1232                         int current_tickcnt = Environment.TickCount;
1233                         if (keysearch_tickcnt > 0 && current_tickcnt - keysearch_tickcnt > keysearch_keydelay) {
1234                                 keysearch_text = string.Empty;
1235                         }
1236
1237                         keysearch_text += (char) ke.KeyData;
1238                         keysearch_tickcnt = current_tickcnt;
1239
1240                         int start = FocusedItem == null ? 0 : FocusedItem.Index;
1241                         int i = start;
1242                         while (true) {
1243                                 if (CultureInfo.CurrentCulture.CompareInfo.IsPrefix (Items[i].Text, keysearch_text,
1244                                         CompareOptions.IgnoreCase)) {
1245                                         SetFocusedItem (Items [i]);
1246                                         items [i].Selected = true;
1247                                         EnsureVisible (i);
1248                                         break;
1249                                 }
1250                                 i = (i + 1  < Items.Count) ? i+1 : 0;
1251
1252                                 if (i == start)
1253                                         break;
1254                         }
1255                         return true;
1256                 }
1257
1258                 int GetAdjustedIndex (Keys key)
1259                 {
1260                         int result = -1;
1261
1262                         if (View == View.Details) {
1263                                 switch (key) {
1264                                 case Keys.Up:
1265                                         result = FocusedItem.Index - 1;
1266                                         break;
1267                                 case Keys.Down:
1268                                         result = FocusedItem.Index + 1;
1269                                         if (result == items.Count)
1270                                                 result = -1;
1271                                         break;
1272                                 case Keys.PageDown:
1273                                         int last_index = LastVisibleIndex;
1274                                         if (Items [last_index].Bounds.Bottom > item_control.ClientRectangle.Bottom)
1275                                                 last_index--;
1276                                         if (FocusedItem.Index == last_index) {
1277                                                 if (FocusedItem.Index < Items.Count - 1) {
1278                                                         int page_size = item_control.Height / items [0].Bounds.Height - 1;
1279                                                         result = FocusedItem.Index + page_size - 1;
1280                                                         if (result >= Items.Count)
1281                                                                 result = Items.Count - 1;
1282                                                 }
1283                                         } else
1284                                                 result = last_index;
1285                                         break;
1286                                 case Keys.PageUp:
1287                                         int first_index = FirstVisibleIndex;
1288                                         if (Items [first_index].Bounds.Y < 0)
1289                                                 first_index++;
1290                                         if (FocusedItem.Index == first_index) {
1291                                                 if (first_index > 0) {
1292                                                         int page_size = item_control.Height / items [0].Bounds.Height - 1;
1293                                                         result = first_index - page_size + 1;
1294                                                         if (result < 0)
1295                                                                 result = 0;
1296                                                 }
1297                                         } else
1298                                                 result = first_index;
1299                                         break;
1300                                 }
1301                                 return result;
1302                         }
1303
1304                         int row = FocusedItem.row;
1305                         int col = FocusedItem.col;
1306
1307                         switch (key) {
1308                         case Keys.Left:
1309                                 if (col == 0)
1310                                         return -1;
1311                                 return item_matrix [row, col - 1].Index;
1312
1313                         case Keys.Right:
1314                                 if (col == (cols - 1))
1315                                         return -1;
1316                                 while (item_matrix [row, col + 1] == null) {
1317                                         row--;
1318                                         if (row < 0)
1319                                                 return -1;
1320                                 }
1321                                 return item_matrix [row, col + 1].Index;
1322
1323                         case Keys.Up:
1324                                 if (row == 0)
1325                                         return -1;
1326                                 return item_matrix [row - 1, col].Index;
1327
1328                         case Keys.Down:
1329                                 if (row == (rows - 1) || row == Items.Count - 1)
1330                                         return -1;
1331                                 while (item_matrix [row + 1, col] == null) {
1332                                         col--;
1333                                         if (col < 0)
1334                                                 return -1;
1335                                 }
1336                                 return item_matrix [row + 1, col].Index;
1337
1338                         default:
1339                                 return -1;
1340                         }
1341                 }
1342
1343                 ListViewItem selection_start;
1344
1345                 private bool SelectItems (ArrayList sel_items)
1346                 {
1347                         bool changed = false;
1348                         ArrayList curr_items = SelectedItems.List;
1349                         foreach (ListViewItem item in curr_items)
1350                                 if (!sel_items.Contains (item)) {
1351                                         item.Selected = false;
1352                                         changed = true;
1353                                 }
1354                         foreach (ListViewItem item in sel_items)
1355                                 if (!item.Selected) {
1356                                         item.Selected = true;
1357                                         changed = true;
1358                                 }
1359                         return changed;
1360                 }
1361
1362                 private void UpdateMultiSelection (int index)
1363                 {
1364                         bool shift_pressed = (XplatUI.State.ModifierKeys & Keys.Shift) != 0;
1365                         bool ctrl_pressed = (XplatUI.State.ModifierKeys & Keys.Control) != 0;
1366                         ListViewItem item = items [index];
1367
1368                         if (shift_pressed && selection_start != null) {
1369                                 ArrayList list = new ArrayList ();
1370                                 int start = Math.Min (selection_start.Index, index);
1371                                 int end = Math.Max (selection_start.Index, index);
1372                                 if (View == View.Details) {
1373                                         for (int i = start; i <= end; i++)
1374                                                 list.Add (items [i]);
1375                                 } else {
1376                                         int left = Math.Min (items [start].col, items [end].col);
1377                                         int right = Math.Max (items [start].col, items [end].col);
1378                                         int top = Math.Min (items [start].row, items [end].row);
1379                                         int bottom = Math.Max (items [start].row, items [end].row);
1380                                         foreach (ListViewItem curr in items)
1381                                                 if (curr.row >= top && curr.row <= bottom &&
1382                                                     curr.col >= left && curr.col <= right)
1383                                                         list.Add (curr);
1384                                 }
1385                                 if (SelectItems (list))
1386                                         OnSelectedIndexChanged (EventArgs.Empty);
1387                         } else  if (ctrl_pressed) {
1388                                 item.Selected = !item.Selected;
1389                                 selection_start = item;
1390                                 OnSelectedIndexChanged (EventArgs.Empty);
1391                         } else {
1392                                 SelectedItems.Clear ();
1393                                 item.Selected = true;
1394                                 selection_start = item;
1395                                 OnSelectedIndexChanged (EventArgs.Empty);
1396                         }
1397                 }
1398
1399                 internal override bool InternalPreProcessMessage (ref Message msg)
1400                 {
1401                         if (msg.Msg == (int)Msg.WM_KEYDOWN) {
1402                                 Keys key_data = (Keys)msg.WParam.ToInt32();
1403                                 if (HandleNavKeys (key_data))
1404                                         return true;
1405                         }
1406                         return base.InternalPreProcessMessage (ref msg);
1407                 }
1408
1409                 bool HandleNavKeys (Keys key_data)
1410                 {
1411                         if (Items.Count == 0 || !item_control.Visible)
1412                                 return false;
1413
1414                         if (FocusedItem == null)
1415                                 SetFocusedItem (Items [0]);
1416
1417                         switch (key_data) {
1418                         case Keys.End:
1419                                 SelectIndex (Items.Count - 1);
1420                                 break;
1421
1422                         case Keys.Home:
1423                                 SelectIndex (0);
1424                                 break;
1425
1426                         case Keys.Left:
1427                         case Keys.Right:
1428                         case Keys.Up:
1429                         case Keys.Down:
1430                         case Keys.PageUp:
1431                         case Keys.PageDown:
1432                                 SelectIndex (GetAdjustedIndex (key_data));
1433                                 break;
1434
1435                         default:
1436                                 return false;
1437                         }
1438
1439                         return true;
1440                 }
1441
1442                 void SelectIndex (int index)
1443                 {
1444                         if (index == -1)
1445                                 return;
1446
1447                         if (MultiSelect)
1448                                 UpdateMultiSelection (index);
1449                         else if (!items [index].Selected) {
1450                                 items [index].Selected = true;
1451                                 OnSelectedIndexChanged (EventArgs.Empty);
1452                         }
1453
1454                         SetFocusedItem (items [index]);
1455                         EnsureVisible (index);
1456                 }
1457
1458                 private void ListView_KeyDown (object sender, KeyEventArgs ke)
1459                 {
1460                         if (ke.Handled || Items.Count == 0 || !item_control.Visible)
1461                                 return;
1462
1463                         ke.Handled = KeySearchString (ke);
1464                 }
1465
1466                 private MouseEventArgs TranslateMouseEventArgs (MouseEventArgs args)
1467                 {
1468                         Point loc = PointToClient (Control.MousePosition);
1469                         return new MouseEventArgs (args.Button, args.Clicks, loc.X, loc.Y, args.Delta);
1470                 }
1471
1472                 internal class ItemControl : Control {
1473
1474                         ListView owner;
1475                         ListViewItem clicked_item;
1476                         ListViewItem last_clicked_item;
1477                         bool hover_processed = false;
1478                         bool checking = false;
1479
1480                         ListViewLabelEditTextBox edit_text_box;
1481                         internal ListViewItem edit_item;
1482                         LabelEditEventArgs edit_args;
1483
1484                         public ItemControl (ListView owner)
1485                         {
1486                                 this.owner = owner;
1487                                 DoubleClick += new EventHandler(ItemsDoubleClick);
1488                                 MouseDown += new MouseEventHandler(ItemsMouseDown);
1489                                 MouseMove += new MouseEventHandler(ItemsMouseMove);
1490                                 MouseHover += new EventHandler(ItemsMouseHover);
1491                                 MouseUp += new MouseEventHandler(ItemsMouseUp);
1492                         }
1493
1494                         void ItemsDoubleClick (object sender, EventArgs e)
1495                         {
1496                                 if (owner.activation == ItemActivation.Standard)
1497                                         owner.OnItemActivate (EventArgs.Empty);
1498                         }
1499
1500                         enum BoxSelect {
1501                                 None,
1502                                 Normal,
1503                                 Shift,
1504                                 Control
1505                         }
1506
1507                         BoxSelect box_select_mode = BoxSelect.None;
1508                         ArrayList prev_selection;
1509                         Point box_select_start;
1510
1511                         Rectangle box_select_rect;
1512                         internal Rectangle BoxSelectRectangle {
1513                                 get { return box_select_rect; }
1514                                 set {
1515                                         if (box_select_rect == value)
1516                                                 return;
1517
1518                                         InvalidateBoxSelectRect ();
1519                                         box_select_rect = value;
1520                                         InvalidateBoxSelectRect ();
1521                                 }
1522                         }
1523
1524                         void InvalidateBoxSelectRect ()
1525                         {
1526                                 if (BoxSelectRectangle.Size.IsEmpty)
1527                                         return;
1528
1529                                 Rectangle edge = BoxSelectRectangle;
1530                                 edge.X -= 1;
1531                                 edge.Y -= 1;
1532                                 edge.Width += 2;
1533                                 edge.Height = 2;
1534                                 Invalidate (edge);
1535                                 edge.Y = BoxSelectRectangle.Bottom - 1;
1536                                 Invalidate (edge);
1537                                 edge.Y = BoxSelectRectangle.Y - 1;
1538                                 edge.Width = 2;
1539                                 edge.Height = BoxSelectRectangle.Height + 2;
1540                                 Invalidate (edge);
1541                                 edge.X = BoxSelectRectangle.Right - 1;
1542                                 Invalidate (edge);
1543                         }
1544
1545                         private Rectangle CalculateBoxSelectRectangle (Point pt)
1546                         {
1547                                 int left = Math.Min (box_select_start.X, pt.X);
1548                                 int right = Math.Max (box_select_start.X, pt.X);
1549                                 int top = Math.Min (box_select_start.Y, pt.Y);
1550                                 int bottom = Math.Max (box_select_start.Y, pt.Y);
1551                                 return Rectangle.FromLTRB (left, top, right, bottom);
1552                         }
1553
1554                         ArrayList BoxSelectedItems {
1555                                 get {
1556                                         ArrayList result = new ArrayList ();
1557                                         foreach (ListViewItem item in owner.Items) {
1558                                                 Rectangle r = item.Bounds;
1559                                                 r.X += r.Width / 4;
1560                                                 r.Y += r.Height / 4;
1561                                                 r.Width /= 2;
1562                                                 r.Height /= 2;
1563                                                 if (BoxSelectRectangle.IntersectsWith (r))
1564                                                         result.Add (item);
1565                                         }
1566                                         return result;
1567                                 }
1568                         }
1569
1570                         private bool PerformBoxSelection (Point pt)
1571                         {
1572                                 if (box_select_mode == BoxSelect.None)
1573                                         return false;
1574
1575                                 BoxSelectRectangle = CalculateBoxSelectRectangle (pt);
1576
1577                                 ArrayList box_items = BoxSelectedItems;
1578
1579                                 ArrayList items;
1580
1581                                 switch (box_select_mode) {
1582
1583                                 case BoxSelect.Normal:
1584                                         items = box_items;
1585                                         break;
1586
1587                                 case BoxSelect.Control:
1588                                         items = new ArrayList ();
1589                                         foreach (ListViewItem item in prev_selection)
1590                                                 if (!box_items.Contains (item))
1591                                                         items.Add (item);
1592                                         foreach (ListViewItem item in box_items)
1593                                                 if (!prev_selection.Contains (item))
1594                                                         items.Add (item);
1595                                         break;
1596
1597                                 case BoxSelect.Shift:
1598                                         items = box_items;
1599                                         foreach (ListViewItem item in box_items)
1600                                                 prev_selection.Remove (item);
1601                                         foreach (ListViewItem item in prev_selection)
1602                                                 items.Add (item);
1603                                         break;
1604
1605                                 default:
1606                                         throw new Exception ("Unexpected Selection mode: " + box_select_mode);
1607                                 }
1608
1609                                 SuspendLayout ();
1610                                 owner.SelectItems (items);
1611                                 ResumeLayout ();
1612
1613                                 return true;
1614                         }
1615
1616                         private void ToggleCheckState (ListViewItem item)
1617                         {
1618                                 CheckState curr_state = item.Checked ?  CheckState.Checked : CheckState.Unchecked;
1619                                 item.Checked = !item.Checked;
1620                                 CheckState new_state = item.Checked ?  CheckState.Checked : CheckState.Unchecked;
1621
1622                                 ItemCheckEventArgs ice = new ItemCheckEventArgs (item.Index, curr_state, new_state);
1623                                 owner.OnItemCheck (ice);
1624                         }
1625
1626                         private void ItemsMouseDown (object sender, MouseEventArgs me)
1627                         {
1628                                 if (owner.items.Count == 0) {
1629                                         owner.OnMouseDown (owner.TranslateMouseEventArgs (me));
1630                                         return;
1631                                 }
1632
1633                                 Point pt = new Point (me.X, me.Y);
1634                                 foreach (ListViewItem item in owner.items) {
1635                                         if (me.Clicks == 1 && item.CheckRectReal.Contains (pt)) {
1636                                                 checking = true;
1637                                                 ToggleCheckState (item);
1638                                                 owner.OnMouseDown (owner.TranslateMouseEventArgs (me));
1639                                                 return;
1640                                         }
1641
1642                                         if (owner.View == View.Details && !owner.FullRowSelect) {
1643                                                 if (item.GetBounds (ItemBoundsPortion.Label).Contains (pt)) {
1644                                                         clicked_item = item;
1645                                                         break;
1646                                                 }
1647                                         } else {
1648                                                 if (item.Bounds.Contains (pt)) {
1649                                                         clicked_item = item;
1650                                                         break;
1651                                                 }
1652                                         }
1653                                 }
1654
1655
1656                                 if (clicked_item != null) {
1657                                         owner.SetFocusedItem (clicked_item);
1658                                         bool changed = !clicked_item.Selected;
1659                                         if (owner.MultiSelect)
1660                                                 owner.UpdateMultiSelection (clicked_item.Index);
1661                                         else
1662                                                 clicked_item.Selected = true;
1663
1664                                         if (changed)
1665                                                 owner.OnSelectedIndexChanged (EventArgs.Empty);
1666
1667                                         // Raise double click if the item was clicked. On MS the
1668                                         // double click is only raised if you double click an item
1669                                         if (me.Clicks > 1) {
1670                                                 owner.OnDoubleClick (EventArgs.Empty);
1671                                                 if (owner.CheckBoxes)
1672                                                         ToggleCheckState (clicked_item);
1673                                         } else if (me.Clicks == 1) {
1674                                                 owner.OnClick (EventArgs.Empty);
1675                                                 if (owner.LabelEdit && !changed)
1676                                                         BeginEdit (clicked_item); // this is probably not the correct place to execute BeginEdit
1677                                         }
1678                                 } else {
1679                                         if (owner.MultiSelect) {
1680                                                 Keys mods = XplatUI.State.ModifierKeys;
1681                                                 if ((mods & Keys.Shift) != 0)
1682                                                         box_select_mode = BoxSelect.Shift;
1683                                                 else if ((mods & Keys.Control) != 0)
1684                                                         box_select_mode = BoxSelect.Control;
1685                                                 else
1686                                                         box_select_mode = BoxSelect.Normal;
1687                                                 box_select_start = pt;
1688                                                 prev_selection = owner.SelectedItems.List;
1689                                         } else if (owner.SelectedItems.Count > 0) {
1690                                                 owner.SelectedItems.Clear ();
1691                                                 owner.OnSelectedIndexChanged (EventArgs.Empty);
1692                                         }
1693                                 }
1694
1695                                 owner.OnMouseDown (owner.TranslateMouseEventArgs (me));
1696                         }
1697
1698                         private void ItemsMouseMove (object sender, MouseEventArgs me)
1699                         {
1700                                 bool done = PerformBoxSelection (new Point (me.X, me.Y));
1701
1702                                 if (!done && owner.HoverSelection && hover_processed) {
1703
1704                                         Point pt = PointToClient (Control.MousePosition);
1705                                         ListViewItem item = owner.GetItemAt (pt.X, pt.Y);
1706                                         if (item != null && !item.Selected) {
1707                                                 hover_processed = false;
1708                                                 XplatUI.ResetMouseHover (Handle);
1709                                         }
1710                                 }
1711
1712                                 owner.OnMouseMove (owner.TranslateMouseEventArgs (me));
1713                         }
1714
1715
1716                         private void ItemsMouseHover (object sender, EventArgs e)
1717                         {
1718                                 owner.OnMouseHover(e);
1719
1720                                 if (Capture || !owner.HoverSelection)
1721                                         return;
1722
1723                                 hover_processed = true;
1724                                 Point pt = PointToClient (Control.MousePosition);
1725                                 ListViewItem item = owner.GetItemAt (pt.X, pt.Y);
1726
1727                                 if (item == null)
1728                                         return;
1729
1730                                 item.Selected = true;
1731                                 owner.OnSelectedIndexChanged (new EventArgs ());
1732                         }
1733
1734                         private void ItemsMouseUp (object sender, MouseEventArgs me)
1735                         {
1736                                 Capture = false;
1737                                 if (owner.Items.Count == 0) {
1738                                         owner.OnMouseUp (owner.TranslateMouseEventArgs (me));
1739                                         return;
1740                                 }
1741
1742                                 Point pt = new Point (me.X, me.Y);
1743
1744                                 Rectangle rect = Rectangle.Empty;
1745                                 if (clicked_item != null) {
1746                                         if (owner.view == View.Details && !owner.full_row_select)
1747                                                 rect = clicked_item.GetBounds (ItemBoundsPortion.Label);
1748                                         else
1749                                                 rect = clicked_item.Bounds;
1750
1751                                         if (rect.Contains (pt)) {
1752                                                 switch (owner.activation) {
1753                                                 case ItemActivation.OneClick:
1754                                                         owner.OnItemActivate (EventArgs.Empty);
1755                                                         break;
1756
1757                                                 case ItemActivation.TwoClick:
1758                                                         if (last_clicked_item == clicked_item) {
1759                                                                 owner.OnItemActivate (EventArgs.Empty);
1760                                                                 last_clicked_item = null;
1761                                                         } else
1762                                                                 last_clicked_item = clicked_item;
1763                                                         break;
1764                                                 default:
1765                                                         // DoubleClick activation is handled in another handler
1766                                                         break;
1767                                                 }
1768                                         }
1769                                 } else if (!checking && owner.SelectedItems.Count > 0 && BoxSelectRectangle.Size.IsEmpty) {
1770                                         // Need this to clean up background clicks
1771                                         owner.SelectedItems.Clear ();
1772                                         owner.OnSelectedIndexChanged (EventArgs.Empty);
1773                                 }
1774
1775                                 clicked_item = null;
1776                                 box_select_start = Point.Empty;
1777                                 BoxSelectRectangle = Rectangle.Empty;
1778                                 prev_selection = null;
1779                                 box_select_mode = BoxSelect.None;
1780                                 checking = false;
1781                                 owner.OnMouseUp (owner.TranslateMouseEventArgs (me));
1782                         }
1783
1784                         internal void LabelEditFinished (object sender, EventArgs e)
1785                         {
1786                                 EndEdit (edit_item);
1787                         }
1788
1789                         internal void BeginEdit (ListViewItem item)
1790                         {
1791                                 if (edit_item != null)
1792                                         EndEdit (edit_item);
1793
1794                                 if (edit_text_box == null) {
1795                                         edit_text_box = new ListViewLabelEditTextBox ();
1796                                         edit_text_box.BorderStyle = BorderStyle.FixedSingle;
1797                                         edit_text_box.EditingFinished += new EventHandler (LabelEditFinished);
1798                                         edit_text_box.Visible = false;
1799                                         Controls.Add (edit_text_box);
1800                                 }
1801
1802                                 item.EnsureVisible();
1803
1804                                 edit_text_box.Reset ();
1805
1806                                 switch (owner.view) {
1807                                         case View.List:
1808                                         case View.SmallIcon:
1809                                         case View.Details:
1810                                                 edit_text_box.TextAlign = HorizontalAlignment.Left;
1811                                                 edit_text_box.Bounds = item.GetBounds (ItemBoundsPortion.Label);
1812                                                 SizeF sizef = DeviceContext.MeasureString (item.Text, item.Font);
1813                                                 edit_text_box.Width = (int)sizef.Width + 4;
1814                                                 edit_text_box.MaxWidth = owner.ClientRectangle.Width - edit_text_box.Bounds.X;
1815                                                 edit_text_box.WordWrap = false;
1816                                                 edit_text_box.Multiline = false;
1817                                                 break;
1818                                         case View.LargeIcon:
1819                                                 edit_text_box.TextAlign = HorizontalAlignment.Center;
1820                                                 edit_text_box.Bounds = item.GetBounds (ItemBoundsPortion.Label);
1821                                                 sizef = DeviceContext.MeasureString (item.Text, item.Font);
1822                                                 edit_text_box.Width = (int)sizef.Width + 4;
1823                                                 edit_text_box.MaxWidth = item.GetBounds(ItemBoundsPortion.Entire).Width;
1824                                                 edit_text_box.MaxHeight = owner.ClientRectangle.Height - edit_text_box.Bounds.Y;
1825                                                 edit_text_box.WordWrap = true;
1826                                                 edit_text_box.Multiline = true;
1827                                                 break;
1828                                 }
1829
1830                                 edit_text_box.Text = item.Text;
1831                                 edit_text_box.Font = item.Font;
1832                                 edit_text_box.Visible = true;
1833                                 edit_text_box.Focus ();
1834                                 edit_text_box.SelectAll ();
1835
1836                                 edit_args = new LabelEditEventArgs (owner.Items.IndexOf(edit_item));
1837                                 owner.OnBeforeLabelEdit (edit_args);
1838
1839                                 if (edit_args.CancelEdit)
1840                                         EndEdit (item);
1841
1842                                 edit_item = item;
1843                         }
1844
1845                         internal void EndEdit (ListViewItem item)
1846                         {
1847                                 if (edit_text_box != null && edit_text_box.Visible) {
1848                                         edit_text_box.Visible = false;
1849                                 }
1850
1851                                 if (edit_item != null && edit_item == item) {
1852                                         owner.OnAfterLabelEdit (edit_args);
1853
1854                                         if (!edit_args.CancelEdit) {
1855                                                 if (edit_args.Label != null)
1856                                                         edit_item.Text = edit_args.Label;
1857                                                 else
1858                                                         edit_item.Text = edit_text_box.Text;
1859                                         }
1860
1861                                 }
1862
1863
1864                                 edit_item = null;
1865                         }
1866
1867                         internal override void OnPaintInternal (PaintEventArgs pe)
1868                         {
1869                                 ThemeEngine.Current.DrawListViewItems (pe.Graphics, pe.ClipRectangle, owner);
1870                         }
1871
1872                         internal override void OnGotFocusInternal (EventArgs e)
1873                         {
1874                                 owner.Select (false, true);
1875                         }
1876
1877                         internal override void OnLostFocusInternal (EventArgs e)
1878                         {
1879                                 owner.Select (false, true);
1880                         }
1881                 }
1882
1883                 internal class ListViewLabelEditTextBox : TextBox
1884                 {
1885                         int max_width = -1;
1886                         int min_width = -1;
1887
1888                         int max_height = -1;
1889                         int min_height = -1;
1890
1891                         int old_number_lines = 1;
1892
1893                         SizeF text_size_one_char;
1894
1895                         public ListViewLabelEditTextBox ()
1896                         {
1897                                 min_height = DefaultSize.Height;
1898                                 text_size_one_char = DeviceContext.MeasureString ("B", Font);
1899                         }
1900
1901                         public int MaxWidth {
1902                                 set {
1903                                         if (value < min_width)
1904                                                 max_width = min_width;
1905                                         else
1906                                                 max_width = value;
1907                                 }
1908                         }
1909
1910                         public int MaxHeight {
1911                                 set {
1912                                         if (value < min_height)
1913                                                 max_height = min_height;
1914                                         else
1915                                                 max_height = value;
1916                                 }
1917                         }
1918
1919                         public new int Width {
1920                                 get {
1921                                         return base.Width;
1922                                 }
1923                                 set {
1924                                         min_width = value;
1925                                         base.Width = value;
1926                                 }
1927                         }
1928
1929                         public override Font Font {
1930                                 get {
1931                                         return base.Font;
1932                                 }
1933                                 set {
1934                                         base.Font = value;
1935                                         text_size_one_char = DeviceContext.MeasureString ("B", Font);
1936                                 }
1937                         }
1938
1939                         protected override void OnTextChanged (EventArgs e)
1940                         {
1941                                 SizeF text_size = DeviceContext.MeasureString (Text, Font);
1942
1943                                 int new_width = (int)text_size.Width + 8;
1944
1945                                 if (!Multiline)
1946                                         ResizeTextBoxWidth (new_width);
1947                                 else {
1948                                         if (Width != max_width)
1949                                                 ResizeTextBoxWidth (new_width);
1950
1951                                         int number_lines = Lines.Length;
1952
1953                                         if (number_lines != old_number_lines) {
1954                                                 int new_height = number_lines * (int)text_size_one_char.Height + 4;
1955                                                 old_number_lines = number_lines;
1956
1957                                                 ResizeTextBoxHeight (new_height);
1958                                         }
1959                                 }
1960
1961                                 base.OnTextChanged (e);
1962                         }
1963
1964                         protected override bool IsInputKey (Keys key_data)
1965                         {
1966                                 if ((key_data & Keys.Alt) == 0) {
1967                                         switch (key_data & Keys.KeyCode) {
1968                                                 case Keys.Enter:
1969                                                         return true;
1970                                         }
1971                                 }
1972                                 return base.IsInputKey (key_data);
1973                         }
1974
1975                         protected override void OnKeyDown (KeyEventArgs e)
1976                         {
1977                                 if (e.KeyCode == Keys.Return && Visible) {
1978                                         this.Visible = false;
1979                                         OnEditingFinished (e);
1980                                 }
1981                         }
1982
1983                         protected override void OnLostFocus (EventArgs e)
1984                         {
1985                                 if (Visible) {
1986                                         OnEditingFinished (e);
1987                                 }
1988                         }
1989
1990                         protected void OnEditingFinished (EventArgs e)
1991                         {
1992                                 EventHandler eh = (EventHandler)(Events [EditingFinishedEvent]);
1993                                 if (eh != null)
1994                                         eh (this, e);
1995                         }
1996
1997                         private void ResizeTextBoxWidth (int new_width)
1998                         {
1999                                 if (new_width > max_width)
2000                                         base.Width = max_width;
2001                                 else
2002                                 if (new_width >= min_width)
2003                                         base.Width = new_width;
2004                                 else
2005                                         base.Width = min_width;
2006                         }
2007
2008                         private void ResizeTextBoxHeight (int new_height)
2009                         {
2010                                 if (new_height > max_height)
2011                                         base.Height = max_height;
2012                                 else
2013                                 if (new_height >= min_height)
2014                                         base.Height = new_height;
2015                                 else
2016                                         base.Height = min_height;
2017                         }
2018
2019                         public void Reset ()
2020                         {
2021                                 max_width = -1;
2022                                 min_width = -1;
2023
2024                                 max_height = -1;
2025
2026                                 old_number_lines = 1;
2027
2028                                 Text = String.Empty;
2029
2030                                 Size = DefaultSize;
2031                         }
2032
2033                         static object EditingFinishedEvent = new object ();
2034                         public event EventHandler EditingFinished {
2035                                 add { Events.AddHandler (EditingFinishedEvent, value); }
2036                                 remove { Events.RemoveHandler (EditingFinishedEvent, value); }
2037                         }
2038                 }
2039
2040                 internal override void OnPaintInternal (PaintEventArgs pe)
2041                 {
2042                         if (updating)
2043                                 return;
2044
2045                         CalculateScrollBars ();
2046                 }
2047
2048                 void FocusChanged (object o, EventArgs args)
2049                 {
2050                         if (Items.Count == 0)
2051                                 return;
2052
2053                         if (FocusedItem == null)
2054                                 SetFocusedItem (Items [0]);
2055
2056                         item_control.Invalidate (FocusedItem.Bounds);
2057                 }
2058
2059                 private void ListView_MouseWheel (object sender, MouseEventArgs me)
2060                 {
2061                         if (Items.Count == 0)
2062                                 return;
2063
2064                         int lines = me.Delta / 120;
2065
2066                         if (lines == 0)
2067                                 return;
2068
2069                         switch (View) {
2070                         case View.Details:
2071                         case View.SmallIcon:
2072                                 Scroll (v_scroll, -Items [0].Bounds.Height * SystemInformation.MouseWheelScrollLines * lines);
2073                                 break;
2074                         case View.LargeIcon:
2075                                 Scroll (v_scroll, -(Items [0].Bounds.Height + ThemeEngine.Current.ListViewVerticalSpacing)  * lines);
2076                                 break;
2077                         case View.List:
2078                                 Scroll (h_scroll, -Items [0].Bounds.Width * lines);
2079                                 break;
2080                         }
2081                 }
2082
2083                 private void ListView_SizeChanged (object sender, EventArgs e)
2084                 {
2085                         CalculateListView (alignment);
2086                 }
2087
2088                 private void SetFocusedItem (ListViewItem item)
2089                 {
2090                         if (focused_item != null)
2091                                 focused_item.Focused = false;
2092
2093                         if (item != null)
2094                                 item.Focused = true;
2095
2096                         focused_item = item;
2097                 }
2098
2099                 private void HorizontalScroller (object sender, EventArgs e)
2100                 {
2101                         item_control.EndEdit (item_control.edit_item);
2102
2103                         // Avoid unnecessary flickering, when button is
2104                         // kept pressed at the end
2105                         if (h_marker != h_scroll.Value) {
2106
2107                                 int pixels =  h_marker - h_scroll.Value;
2108
2109                                 h_marker = h_scroll.Value;
2110                                 if (header_control.Visible)
2111                                         XplatUI.ScrollWindow (header_control.Handle, pixels, 0, false);
2112
2113                                 XplatUI.ScrollWindow (item_control.Handle, pixels, 0, false);
2114                         }
2115                 }
2116
2117                 private void VerticalScroller (object sender, EventArgs e)
2118                 {
2119                         item_control.EndEdit (item_control.edit_item);
2120
2121                         // Avoid unnecessary flickering, when button is
2122                         // kept pressed at the end
2123                         if (v_marker != v_scroll.Value) {
2124                                 int pixels =  v_marker - v_scroll.Value;
2125                                 Rectangle area = item_control.ClientRectangle;
2126                                 v_marker = v_scroll.Value;
2127                                 XplatUI.ScrollWindow (item_control.Handle, area, 0, pixels, false);
2128                         }
2129                 }
2130                 #endregion      // Internal Methods Properties
2131
2132                 #region Protected Methods
2133                 protected override void CreateHandle ()
2134                 {
2135                         base.CreateHandle ();
2136                         for (int i = 0; i < SelectedItems.Count; i++)
2137                                 OnSelectedIndexChanged (EventArgs.Empty);
2138                 }
2139
2140                 protected override void Dispose (bool disposing)
2141                 {
2142                         if (disposing) {
2143                                 h_scroll.Dispose ();
2144                                 v_scroll.Dispose ();
2145
2146                                 large_image_list = null;
2147                                 small_image_list = null;
2148                                 state_image_list = null;
2149                         }
2150
2151                         base.Dispose (disposing);
2152                 }
2153
2154                 protected override bool IsInputKey (Keys keyData)
2155                 {
2156                         switch (keyData) {
2157                         case Keys.Up:
2158                         case Keys.Down:
2159                         case Keys.PageUp:
2160                         case Keys.PageDown:
2161                         case Keys.Right:
2162                         case Keys.Left:
2163                         case Keys.End:
2164                         case Keys.Home:
2165                                 return true;
2166
2167                         default:
2168                                 break;
2169                         }
2170
2171                         return base.IsInputKey (keyData);
2172                 }
2173
2174                 protected virtual void OnAfterLabelEdit (LabelEditEventArgs e)
2175                 {
2176                         LabelEditEventHandler eh = (LabelEditEventHandler)(Events [AfterLabelEditEvent]);
2177                         if (eh != null)
2178                                 eh (this, e);
2179                 }
2180
2181                 protected virtual void OnBeforeLabelEdit (LabelEditEventArgs e)
2182                 {
2183                         LabelEditEventHandler eh = (LabelEditEventHandler)(Events [BeforeLabelEditEvent]);
2184                         if (eh != null)
2185                                 eh (this, e);
2186                 }
2187
2188                 protected virtual void OnColumnClick (ColumnClickEventArgs e)
2189                 {
2190                         ColumnClickEventHandler eh = (ColumnClickEventHandler)(Events [ColumnClickEvent]);
2191                         if (eh != null)
2192                                 eh (this, e);
2193                 }
2194
2195                 protected override void OnEnabledChanged (EventArgs e)
2196                 {
2197                         base.OnEnabledChanged (e);
2198                 }
2199
2200                 protected override void OnFontChanged (EventArgs e)
2201                 {
2202                         base.OnFontChanged (e);
2203                         Redraw (true);
2204                 }
2205
2206                 protected override void OnHandleCreated (EventArgs e)
2207                 {
2208                         base.OnHandleCreated (e);
2209                         Sort ();
2210                 }
2211
2212                 protected override void OnHandleDestroyed (EventArgs e)
2213                 {
2214                         base.OnHandleDestroyed (e);
2215                 }
2216
2217                 protected virtual void OnItemActivate (EventArgs e)
2218                 {
2219                         EventHandler eh = (EventHandler)(Events [ItemActivateEvent]);
2220                         if (eh != null)
2221                                 eh (this, e);
2222                 }
2223
2224                 protected virtual void OnItemCheck (ItemCheckEventArgs ice)
2225                 {
2226                         EventHandler eh = (EventHandler)(Events [ItemCheckEvent]);
2227                         if (eh != null)
2228                                 eh (this, ice);
2229                 }
2230
2231                 protected virtual void OnItemDrag (ItemDragEventArgs e)
2232                 {
2233                         EventHandler eh = (EventHandler)(Events [ItemDragEvent]);
2234                         if (eh != null)
2235                                 eh (this, e);
2236                 }
2237
2238                 protected virtual void OnSelectedIndexChanged (EventArgs e)
2239                 {
2240                         EventHandler eh = (EventHandler)(Events [SelectedIndexChangedEvent]);
2241                         if (eh != null)
2242                                 eh (this, e);
2243                 }
2244
2245                 protected override void OnSystemColorsChanged (EventArgs e)
2246                 {
2247                         base.OnSystemColorsChanged (e);
2248                 }
2249
2250                 protected void RealizeProperties ()
2251                 {
2252                         // FIXME: TODO
2253                 }
2254
2255                 protected void UpdateExtendedStyles ()
2256                 {
2257                         // FIXME: TODO
2258                 }
2259
2260                 bool refocusing = false;
2261
2262                 protected override void WndProc (ref Message m)
2263                 {
2264                         switch ((Msg)m.Msg) {
2265                         case Msg.WM_KILLFOCUS:
2266                                 Control receiver = Control.FromHandle (m.WParam);
2267                                 if (receiver == item_control) {
2268                                         has_focus = false;
2269                                         refocusing = true;
2270                                         return;
2271                                 }
2272                                 break;
2273                         case Msg.WM_SETFOCUS:
2274                                 if (refocusing) {
2275                                         has_focus = true;
2276                                         refocusing = false;
2277                                         return;
2278                                 }
2279                                 break;
2280                         default:
2281                                 break;
2282                         }
2283                         base.WndProc (ref m);
2284                 }
2285                 #endregion // Protected Methods
2286
2287                 #region Public Instance Methods
2288                 public void ArrangeIcons ()
2289                 {
2290                         ArrangeIcons (this.alignment);
2291                 }
2292
2293                 public void ArrangeIcons (ListViewAlignment alignment)
2294                 {
2295                         // Icons are arranged only if view is set to LargeIcon or SmallIcon
2296                         if (view == View.LargeIcon || view == View.SmallIcon) {
2297                                 this.CalculateListView (alignment);
2298                                 // we have done the calculations already
2299                                 this.Redraw (false);
2300                         }
2301                 }
2302
2303                 public void BeginUpdate ()
2304                 {
2305                         // flag to avoid painting
2306                         updating = true;
2307                 }
2308
2309                 public void Clear ()
2310                 {
2311                         columns.Clear ();
2312                         items.Clear (); // Redraw (true) called here
2313                 }
2314
2315                 public void EndUpdate ()
2316                 {
2317                         // flag to avoid painting
2318                         updating = false;
2319
2320                         // probably, now we need a redraw with recalculations
2321                         this.Redraw (true);
2322                 }
2323
2324                 public void EnsureVisible (int index)
2325                 {
2326                         if (index < 0 || index >= items.Count || scrollable == false)
2327                                 return;
2328
2329                         Rectangle view_rect = item_control.ClientRectangle;
2330                         Rectangle bounds = items [index].Bounds;
2331
2332                         if (view_rect.Contains (bounds))
2333                                 return;
2334
2335                         if (View != View.Details) {
2336                                 if (bounds.Left < 0)
2337                                         h_scroll.Value += bounds.Left;
2338                                 else if (bounds.Right > view_rect.Right)
2339                                         h_scroll.Value += (bounds.Right - view_rect.Right);
2340                         }
2341
2342                         if (bounds.Top < 0)
2343                                 v_scroll.Value += bounds.Top;
2344                         else if (bounds.Bottom > view_rect.Bottom)
2345                                 v_scroll.Value += (bounds.Bottom - view_rect.Bottom);
2346                 }
2347
2348                 public ListViewItem GetItemAt (int x, int y)
2349                 {
2350                         foreach (ListViewItem item in items) {
2351                                 if (item.Bounds.Contains (x, y))
2352                                         return item;
2353                         }
2354                         return null;
2355                 }
2356
2357                 public Rectangle GetItemRect (int index)
2358                 {
2359                         return GetItemRect (index, ItemBoundsPortion.Entire);
2360                 }
2361
2362                 public Rectangle GetItemRect (int index, ItemBoundsPortion portion)
2363                 {
2364                         if (index < 0 || index >= items.Count)
2365                                 throw new IndexOutOfRangeException ("index");
2366
2367                         return items [index].GetBounds (portion);
2368                 }
2369
2370                 public void Sort ()
2371                 {
2372                         Sort (true);
2373                 }
2374
2375                 // we need this overload to reuse the logic for sorting, while allowing
2376                 // redrawing to be done by caller or have it done by this method when
2377                 // sorting is really performed
2378                 //
2379                 // ListViewItemCollection's Add and AddRange methods call this overload
2380                 // with redraw set to false, as they take care of redrawing themselves
2381                 // (they even want to redraw the listview if no sort is performed, as
2382                 // an item was added), while ListView.Sort () only wants to redraw if
2383                 // sorting was actually performed
2384                 private void Sort (bool redraw)
2385                 {
2386                         if (!IsHandleCreated || item_sorter == null) {
2387                                 return;
2388                         }
2389
2390                         items.Sort (item_sorter);
2391                         if (redraw)
2392                                 this.Redraw (true);
2393                 }
2394
2395                 public override string ToString ()
2396                 {
2397                         int count = this.Items.Count;
2398
2399                         if (count == 0)
2400                                 return string.Format ("System.Windows.Forms.ListView, Items.Count: 0");
2401                         else
2402                                 return string.Format ("System.Windows.Forms.ListView, Items.Count: {0}, Items[0]: {1}", count, this.Items [0].ToString ());
2403                 }
2404                 #endregion      // Public Instance Methods
2405
2406
2407                 #region Subclasses
2408
2409                 class HeaderControl : Control {
2410
2411                         ListView owner;
2412                         bool column_resize_active = false;
2413                         ColumnHeader resize_column;
2414                         ColumnHeader clicked_column;
2415                         ColumnHeader drag_column;
2416                         int drag_x;
2417                         int drag_to_index = -1;
2418
2419                         public HeaderControl (ListView owner)
2420                         {
2421                                 this.owner = owner;
2422                                 MouseDown += new MouseEventHandler (HeaderMouseDown);
2423                                 MouseMove += new MouseEventHandler (HeaderMouseMove);
2424                                 MouseUp += new MouseEventHandler (HeaderMouseUp);
2425                         }
2426
2427                         private ColumnHeader ColumnAtX (int x)
2428                         {
2429                                 Point pt = new Point (x, 0);
2430                                 ColumnHeader result = null;
2431                                 foreach (ColumnHeader col in owner.Columns) {
2432                                         if (col.Rect.Contains (pt)) {
2433                                                 result = col;
2434                                                 break;
2435                                         }
2436                                 }
2437                                 return result;
2438                         }
2439
2440                         private int GetReorderedIndex (ColumnHeader col)
2441                         {
2442                                 if (owner.reordered_column_indices == null)
2443                                         return col.Index;
2444                                 else
2445                                         for (int i = 0; i < owner.Columns.Count; i++)
2446                                                 if (owner.reordered_column_indices [i] == col.Index)
2447                                                         return i;
2448                                 throw new Exception ("Column index missing from reordered array");
2449                         }
2450
2451                         private void HeaderMouseDown (object sender, MouseEventArgs me)
2452                         {
2453                                 if (resize_column != null) {
2454                                         column_resize_active = true;
2455                                         Capture = true;
2456                                         return;
2457                                 }
2458
2459                                 clicked_column = ColumnAtX (me.X + owner.h_marker);
2460
2461                                 if (clicked_column != null) {
2462                                         Capture = true;
2463                                         if (owner.AllowColumnReorder) {
2464                                                 drag_x = me.X;
2465                                                 drag_column = (ColumnHeader) (clicked_column as ICloneable).Clone ();
2466                                                 drag_column.Rect = clicked_column.Rect;
2467                                                 drag_to_index = GetReorderedIndex (clicked_column);
2468                                         }
2469                                         clicked_column.Pressed = true;
2470                                         Rectangle bounds = clicked_column.Rect;
2471                                         bounds.X -= owner.h_marker;
2472                                         Invalidate (bounds);
2473                                         return;
2474                                 }
2475                         }
2476
2477                         void StopResize ()
2478                         {
2479                                 column_resize_active = false;
2480                                 resize_column = null;
2481                                 Capture = false;
2482                                 Cursor = Cursors.Default;
2483                         }
2484
2485                         private void HeaderMouseMove (object sender, MouseEventArgs me)
2486                         {
2487                                 Point pt = new Point (me.X + owner.h_marker, me.Y);
2488
2489                                 if (column_resize_active)  {
2490                                         int width = pt.X - resize_column.X;
2491                                         if (width < 0)
2492                                                 width = 0;
2493
2494                                         if (!owner.CanProceedWithResize (resize_column, width)){
2495                                                 StopResize ();
2496                                                 return;
2497                                         }
2498                                         resize_column.Width = width;
2499                                         return;
2500                                 }
2501
2502                                 resize_column = null;
2503
2504                                 if (clicked_column != null) {
2505                                         if (owner.AllowColumnReorder) {
2506                                                 Rectangle r;
2507
2508                                                 r = drag_column.Rect;
2509                                                 r.X = clicked_column.Rect.X + me.X - drag_x;
2510                                                 drag_column.Rect = r;
2511
2512                                                 int x = me.X + owner.h_marker;
2513                                                 ColumnHeader over = ColumnAtX (x);
2514                                                 if (over == null)
2515                                                         drag_to_index = owner.Columns.Count;
2516                                                 else if (x < over.X + over.Width / 2)
2517                                                         drag_to_index = GetReorderedIndex (over);
2518                                                 else
2519                                                         drag_to_index = GetReorderedIndex (over) + 1;
2520                                                 Invalidate ();
2521                                         } else {
2522                                                 ColumnHeader over = ColumnAtX (me.X + owner.h_marker);
2523                                                 bool pressed = clicked_column.Pressed;
2524                                                 clicked_column.Pressed = over == clicked_column;
2525                                                 if (clicked_column.Pressed ^ pressed) {
2526                                                         Rectangle bounds = clicked_column.Rect;
2527                                                         bounds.X -= owner.h_marker;
2528                                                         Invalidate (bounds);
2529                                                 }
2530                                         }
2531                                         return;
2532                                 }
2533
2534                                 for (int i = 0; i < owner.Columns.Count; i++) {
2535                                         Rectangle zone = owner.Columns [i].Rect;
2536                                         zone.X = zone.Right - 5;
2537                                         zone.Width = 10;
2538                                         if (zone.Contains (pt)) {
2539                                                 if (i < owner.Columns.Count - 1 && owner.Columns [i + 1].Width == 0)
2540                                                         i++;
2541                                                 resize_column = owner.Columns [i];
2542                                                 break;
2543                                         }
2544                                 }
2545
2546                                 if (resize_column == null)
2547                                         Cursor = Cursors.Default;
2548                                 else
2549                                         Cursor = Cursors.VSplit;
2550                         }
2551
2552                         void HeaderMouseUp (object sender, MouseEventArgs me)
2553                         {
2554                                 Capture = false;
2555
2556                                 if (column_resize_active) {
2557                                         int column_idx = resize_column.Index;
2558                                         StopResize ();
2559                                         owner.RaiseColumnWidthChanged (column_idx);
2560                                         return;
2561                                 }
2562
2563                                 if (clicked_column != null && clicked_column.Pressed) {
2564                                         clicked_column.Pressed = false;
2565                                         Rectangle bounds = clicked_column.Rect;
2566                                         bounds.X -= owner.h_marker;
2567                                         Invalidate (bounds);
2568                                         owner.OnColumnClick (new ColumnClickEventArgs (clicked_column.Index));
2569                                 }
2570
2571                                 if (drag_column != null && owner.AllowColumnReorder) {
2572                                         drag_column = null;
2573                                         if (drag_to_index > GetReorderedIndex (clicked_column))
2574                                                 drag_to_index--;
2575                                         if (owner.GetReorderedColumn (drag_to_index) != clicked_column)
2576                                                 owner.ReorderColumn (clicked_column, drag_to_index);
2577                                         drag_to_index = -1;
2578                                         Invalidate ();
2579                                 }
2580
2581                                 clicked_column = null;
2582                         }
2583
2584                         internal override void OnPaintInternal (PaintEventArgs pe)
2585                         {
2586                                 if (owner.updating)
2587                                         return;
2588
2589                                 Theme theme = ThemeEngine.Current;
2590                                 theme.DrawListViewHeader (pe.Graphics, pe.ClipRectangle, this.owner);
2591
2592                                 if (drag_column == null)
2593                                         return;
2594
2595                                 int target_x;
2596                                 if (drag_to_index == owner.Columns.Count)
2597                                         target_x = owner.GetReorderedColumn (drag_to_index - 1).Rect.Right - owner.h_marker;
2598                                 else
2599                                         target_x = owner.GetReorderedColumn (drag_to_index).Rect.X - owner.h_marker;
2600                                 theme.DrawListViewHeaderDragDetails (pe.Graphics, owner, drag_column, target_x);
2601                         }
2602
2603                         protected override void WndProc (ref Message m)
2604                         {
2605                                 switch ((Msg)m.Msg) {
2606                                 case Msg.WM_SETFOCUS:
2607                                         owner.Focus ();
2608                                         break;
2609                                 default:
2610                                         base.WndProc (ref m);
2611                                         break;
2612                                 }
2613                         }
2614                 }
2615
2616                 private class ItemComparer : IComparer {
2617                         readonly SortOrder sort_order;
2618
2619                         public ItemComparer (SortOrder sortOrder)
2620                         {
2621                                 sort_order = sortOrder;
2622                         }
2623
2624                         public int Compare (object x, object y)
2625                         {
2626                                 ListViewItem item_x = x as ListViewItem;
2627                                 ListViewItem item_y = y as ListViewItem;
2628                                 if (sort_order == SortOrder.Ascending)
2629                                         return String.Compare (item_x.Text, item_y.Text);
2630                                 else
2631                                         return String.Compare (item_y.Text, item_x.Text);
2632                         }
2633                 }
2634
2635                 public class CheckedIndexCollection : IList, ICollection, IEnumerable
2636                 {
2637                         private readonly ListView owner;
2638
2639                         #region Public Constructor
2640                         public CheckedIndexCollection (ListView owner)
2641                         {
2642                                 this.owner = owner;
2643                         }
2644                         #endregion      // Public Constructor
2645
2646                         #region Public Properties
2647                         [Browsable (false)]
2648                         public int Count {
2649                                 get { return owner.CheckedItems.Count; }
2650                         }
2651
2652                         public bool IsReadOnly {
2653                                 get { return true; }
2654                         }
2655
2656                         public int this [int index] {
2657                                 get {
2658                                         int [] indices = GetIndices ();
2659                                         if (index < 0 || index >= indices.Length)
2660                                                 throw new ArgumentOutOfRangeException ("index");
2661                                         return indices [index];
2662                                 }
2663                         }
2664
2665                         bool ICollection.IsSynchronized {
2666                                 get { return false; }
2667                         }
2668
2669                         object ICollection.SyncRoot {
2670                                 get { return this; }
2671                         }
2672
2673                         bool IList.IsFixedSize {
2674                                 get { return true; }
2675                         }
2676
2677                         object IList.this [int index] {
2678                                 get { return this [index]; }
2679                                 set { throw new NotSupportedException ("SetItem operation is not supported."); }
2680                         }
2681                         #endregion      // Public Properties
2682
2683                         #region Public Methods
2684                         public bool Contains (int checkedIndex)
2685                         {
2686                                 int [] indices = GetIndices ();
2687                                 for (int i = 0; i < indices.Length; i++) {
2688                                         if (indices [i] == checkedIndex)
2689                                                 return true;
2690                                 }
2691                                 return false;
2692                         }
2693
2694                         public IEnumerator GetEnumerator ()
2695                         {
2696                                 int [] indices = GetIndices ();
2697                                 return indices.GetEnumerator ();
2698                         }
2699
2700                         void ICollection.CopyTo (Array dest, int index)
2701                         {
2702                                 int [] indices = GetIndices ();
2703                                 Array.Copy (indices, 0, dest, index, indices.Length);
2704                         }
2705
2706                         int IList.Add (object value)
2707                         {
2708                                 throw new NotSupportedException ("Add operation is not supported.");
2709                         }
2710
2711                         void IList.Clear ()
2712                         {
2713                                 throw new NotSupportedException ("Clear operation is not supported.");
2714                         }
2715
2716                         bool IList.Contains (object checkedIndex)
2717                         {
2718                                 if (!(checkedIndex is int))
2719                                         return false;
2720                                 return Contains ((int) checkedIndex);
2721                         }
2722
2723                         int IList.IndexOf (object checkedIndex)
2724                         {
2725                                 if (!(checkedIndex is int))
2726                                         return -1;
2727                                 return IndexOf ((int) checkedIndex);
2728                         }
2729
2730                         void IList.Insert (int index, object value)
2731                         {
2732                                 throw new NotSupportedException ("Insert operation is not supported.");
2733                         }
2734
2735                         void IList.Remove (object value)
2736                         {
2737                                 throw new NotSupportedException ("Remove operation is not supported.");
2738                         }
2739
2740                         void IList.RemoveAt (int index)
2741                         {
2742                                 throw new NotSupportedException ("RemoveAt operation is not supported.");
2743                         }
2744
2745                         public int IndexOf (int checkedIndex)
2746                         {
2747                                 int [] indices = GetIndices ();
2748                                 for (int i = 0; i < indices.Length; i++) {
2749                                         if (indices [i] == checkedIndex)
2750                                                 return i;
2751                                 }
2752                                 return -1;
2753                         }
2754                         #endregion      // Public Methods
2755
2756                         private int [] GetIndices ()
2757                         {
2758                                 ArrayList checked_items = owner.CheckedItems.List;
2759                                 int [] indices = new int [checked_items.Count];
2760                                 for (int i = 0; i < checked_items.Count; i++) {
2761                                         ListViewItem item = (ListViewItem) checked_items [i];
2762                                         indices [i] = item.Index;
2763                                 }
2764                                 return indices;
2765                         }
2766                 }       // CheckedIndexCollection
2767
2768                 public class CheckedListViewItemCollection : IList, ICollection, IEnumerable
2769                 {
2770                         private readonly ListView owner;
2771                         private ArrayList list;
2772
2773                         #region Public Constructor
2774                         public CheckedListViewItemCollection (ListView owner)
2775                         {
2776                                 this.owner = owner;
2777                                 this.owner.Items.Changed += new CollectionChangedHandler (
2778                                         ItemsCollection_Changed);
2779                         }
2780                         #endregion      // Public Constructor
2781
2782                         #region Public Properties
2783                         [Browsable (false)]
2784                         public int Count {
2785                                 get {
2786                                         if (!owner.CheckBoxes)
2787                                                 return 0;
2788                                         return List.Count;
2789                                 }
2790                         }
2791
2792                         public bool IsReadOnly {
2793                                 get { return true; }
2794                         }
2795
2796                         public ListViewItem this [int index] {
2797                                 get {
2798                                         ArrayList checked_items = List;
2799                                         if (index < 0 || index >= checked_items.Count)
2800                                                 throw new ArgumentOutOfRangeException ("index");
2801                                         return (ListViewItem) checked_items [index];
2802                                 }
2803                         }
2804
2805 #if NET_2_0
2806                         public virtual ListViewItem this [string key] {
2807                                 get {
2808                                         int idx = IndexOfKey (key);
2809                                         return idx == -1 ? null : (ListViewItem) List [idx];
2810                                 }
2811                         }
2812 #endif
2813
2814                         bool ICollection.IsSynchronized {
2815                                 get { return false; }
2816                         }
2817
2818                         object ICollection.SyncRoot {
2819                                 get { return this; }
2820                         }
2821
2822                         bool IList.IsFixedSize {
2823                                 get { return true; }
2824                         }
2825
2826                         object IList.this [int index] {
2827                                 get { return this [index]; }
2828                                 set { throw new NotSupportedException ("SetItem operation is not supported."); }
2829                         }
2830                         #endregion      // Public Properties
2831
2832                         #region Public Methods
2833                         public bool Contains (ListViewItem item)
2834                         {
2835                                 if (!owner.CheckBoxes)
2836                                         return false;
2837                                 return List.Contains (item);
2838                         }
2839
2840 #if NET_2_0
2841                         public virtual bool ContainsKey (string key)
2842                         {
2843                                 return IndexOfKey (key) != -1;
2844                         }
2845 #endif
2846
2847                         public void CopyTo (Array dest, int index)
2848                         {
2849                                 if (!owner.CheckBoxes)
2850                                         return;
2851                                 List.CopyTo (dest, index);
2852                         }
2853
2854                         public IEnumerator GetEnumerator ()
2855                         {
2856                                 if (!owner.CheckBoxes)
2857                                         return (new ListViewItem [0]).GetEnumerator ();
2858                                 return List.GetEnumerator ();
2859                         }
2860
2861                         int IList.Add (object value)
2862                         {
2863                                 throw new NotSupportedException ("Add operation is not supported.");
2864                         }
2865
2866                         void IList.Clear ()
2867                         {
2868                                 throw new NotSupportedException ("Clear operation is not supported.");
2869                         }
2870
2871                         bool IList.Contains (object item)
2872                         {
2873                                 if (!(item is ListViewItem))
2874                                         return false;
2875                                 return Contains ((ListViewItem) item);
2876                         }
2877
2878                         int IList.IndexOf (object item)
2879                         {
2880                                 if (!(item is ListViewItem))
2881                                         return -1;
2882                                 return IndexOf ((ListViewItem) item);
2883                         }
2884
2885                         void IList.Insert (int index, object value)
2886                         {
2887                                 throw new NotSupportedException ("Insert operation is not supported.");
2888                         }
2889
2890                         void IList.Remove (object value)
2891                         {
2892                                 throw new NotSupportedException ("Remove operation is not supported.");
2893                         }
2894
2895                         void IList.RemoveAt (int index)
2896                         {
2897                                 throw new NotSupportedException ("RemoveAt operation is not supported.");
2898                         }
2899
2900                         public int IndexOf (ListViewItem item)
2901                         {
2902                                 if (!owner.CheckBoxes)
2903                                         return -1;
2904                                 return List.IndexOf (item);
2905                         }
2906
2907 #if NET_2_0
2908                         public virtual int IndexOfKey (string key)
2909                         {
2910                                 if (key == null || key.Length == 0)
2911                                         return -1;
2912
2913                                 ArrayList checked_items = List;
2914                                 for (int i = 0; i < checked_items.Count; i++) {
2915                                         ListViewItem item = (ListViewItem) checked_items [i];
2916                                         if (String.Compare (key, item.Name, true) == 0)
2917                                                 return i;
2918                                 }
2919
2920                                 return -1;
2921                         }
2922 #endif
2923                         #endregion      // Public Methods
2924
2925                         internal ArrayList List {
2926                                 get {
2927                                         if (list == null) {
2928                                                 list = new ArrayList ();
2929                                                 foreach (ListViewItem item in owner.Items) {
2930                                                         if (item.Checked)
2931                                                                 list.Add (item);
2932                                                 }
2933                                         }
2934                                         return list;
2935                                 }
2936                         }
2937
2938                         internal void Reset ()
2939                         {
2940                                 // force re-population of list
2941                                 list = null;
2942                         }
2943
2944                         private void ItemsCollection_Changed ()
2945                         {
2946                                 Reset ();
2947                         }
2948                 }       // CheckedListViewItemCollection
2949
2950                 public class ColumnHeaderCollection : IList, ICollection, IEnumerable
2951                 {
2952                         internal ArrayList list;
2953                         private ListView owner;
2954
2955                         #region Public Constructor
2956                         public ColumnHeaderCollection (ListView owner)
2957                         {
2958                                 list = new ArrayList ();
2959                                 this.owner = owner;
2960                         }
2961                         #endregion      // Public Constructor
2962
2963                         #region Public Properties
2964                         [Browsable (false)]
2965                         public int Count {
2966                                 get { return list.Count; }
2967                         }
2968
2969                         public bool IsReadOnly {
2970                                 get { return false; }
2971                         }
2972
2973                         public virtual ColumnHeader this [int index] {
2974                                 get {
2975                                         if (index < 0 || index >= list.Count)
2976                                                 throw new ArgumentOutOfRangeException ("index");
2977                                         return (ColumnHeader) list [index];
2978                                 }
2979                         }
2980
2981 #if NET_2_0
2982                         public virtual ColumnHeader this [string key] {
2983                                 get {
2984                                         int idx = IndexOfKey (key);
2985                                         if (idx == -1)
2986                                                 return null;
2987
2988                                         return (ColumnHeader) list [idx];
2989                                 }
2990                         }
2991 #endif
2992
2993                         bool ICollection.IsSynchronized {
2994                                 get { return true; }
2995                         }
2996
2997                         object ICollection.SyncRoot {
2998                                 get { return this; }
2999                         }
3000
3001                         bool IList.IsFixedSize {
3002                                 get { return list.IsFixedSize; }
3003                         }
3004
3005                         object IList.this [int index] {
3006                                 get { return this [index]; }
3007                                 set { throw new NotSupportedException ("SetItem operation is not supported."); }
3008                         }
3009                         #endregion      // Public Properties
3010
3011                         #region Public Methods
3012                         public virtual int Add (ColumnHeader value)
3013                         {
3014                                 int idx;
3015                                 value.SetListView (this.owner);
3016                                 idx = list.Add (value);
3017                                 if (owner.IsHandleCreated) {
3018                                         owner.Redraw (true);
3019                                 }
3020                                 return idx;
3021                         }
3022
3023                         public virtual ColumnHeader Add (string str, int width, HorizontalAlignment textAlign)
3024                         {
3025                                 ColumnHeader colHeader = new ColumnHeader (this.owner, str, textAlign, width);
3026                                 this.Add (colHeader);
3027                                 return colHeader;
3028                         }
3029
3030 #if NET_2_0
3031                         public virtual ColumnHeader Add (string text)
3032                         {
3033                                 return Add (String.Empty, text);
3034                         }
3035
3036                         public virtual ColumnHeader Add (string text, int iwidth)
3037                         {
3038                                 return Add (String.Empty, text, iwidth);
3039                         }
3040
3041                         public virtual ColumnHeader Add (string key, string text)
3042                         {
3043                                 ColumnHeader colHeader = new ColumnHeader ();
3044                                 colHeader.Name = key;
3045                                 colHeader.Text = text;
3046                                 Add (colHeader);
3047                                 return colHeader;
3048                         }
3049
3050                         public virtual ColumnHeader Add (string key, string text, int iwidth)
3051                         {
3052                                 return Add (key, text, iwidth, HorizontalAlignment.Left, -1);
3053                         }
3054
3055                         public virtual ColumnHeader Add (string key, string text, int iwidth, HorizontalAlignment textAlign, int imageIndex)
3056                         {
3057                                 ColumnHeader colHeader = new ColumnHeader (key, text, iwidth, textAlign);
3058                                 colHeader.ImageIndex = imageIndex;
3059                                 Add (colHeader);
3060                                 return colHeader;
3061                         }
3062
3063                         public virtual ColumnHeader Add (string key, string text, int iwidth, HorizontalAlignment textAlign, string imageKey)
3064                         {
3065                                 ColumnHeader colHeader = new ColumnHeader (key, text, iwidth, textAlign);
3066                                 colHeader.ImageKey = imageKey;
3067                                 Add (colHeader);
3068                                 return colHeader;
3069                         }
3070 #endif
3071
3072                         public virtual void AddRange (ColumnHeader [] values)
3073                         {
3074                                 foreach (ColumnHeader colHeader in values) {
3075                                         colHeader.SetListView (this.owner);
3076                                         Add (colHeader);
3077                                 }
3078
3079                                 owner.Redraw (true);
3080                         }
3081
3082                         public virtual void Clear ()
3083                         {
3084                                 list.Clear ();
3085                                 owner.Redraw (true);
3086                         }
3087
3088                         public bool Contains (ColumnHeader value)
3089                         {
3090                                 return list.Contains (value);
3091                         }
3092
3093 #if NET_2_0
3094                         public virtual bool ContainsKey (string key)
3095                         {
3096                                 return IndexOfKey (key) != -1;
3097                         }
3098 #endif
3099
3100                         public IEnumerator GetEnumerator ()
3101                         {
3102                                 return list.GetEnumerator ();
3103                         }
3104
3105                         void ICollection.CopyTo (Array dest, int index)
3106                         {
3107                                 list.CopyTo (dest, index);
3108                         }
3109
3110                         int IList.Add (object value)
3111                         {
3112                                 if (! (value is ColumnHeader)) {
3113                                         throw new ArgumentException ("Not of type ColumnHeader", "value");
3114                                 }
3115
3116                                 return this.Add ((ColumnHeader) value);
3117                         }
3118
3119                         bool IList.Contains (object value)
3120                         {
3121                                 if (! (value is ColumnHeader)) {
3122                                         throw new ArgumentException ("Not of type ColumnHeader", "value");
3123                                 }
3124
3125                                 return this.Contains ((ColumnHeader) value);
3126                         }
3127
3128                         int IList.IndexOf (object value)
3129                         {
3130                                 if (! (value is ColumnHeader)) {
3131                                         throw new ArgumentException ("Not of type ColumnHeader", "value");
3132                                 }
3133
3134                                 return this.IndexOf ((ColumnHeader) value);
3135                         }
3136
3137                         void IList.Insert (int index, object value)
3138                         {
3139                                 if (! (value is ColumnHeader)) {
3140                                         throw new ArgumentException ("Not of type ColumnHeader", "value");
3141                                 }
3142
3143                                 this.Insert (index, (ColumnHeader) value);
3144                         }
3145
3146                         void IList.Remove (object value)
3147                         {
3148                                 if (! (value is ColumnHeader)) {
3149                                         throw new ArgumentException ("Not of type ColumnHeader", "value");
3150                                 }
3151
3152                                 this.Remove ((ColumnHeader) value);
3153                         }
3154
3155                         public int IndexOf (ColumnHeader value)
3156                         {
3157                                 return list.IndexOf (value);
3158                         }
3159
3160 #if NET_2_0
3161                         public virtual int IndexOfKey (string key)
3162                         {
3163                                 if (key == null || key.Length == 0)
3164                                         return -1;
3165
3166                                 for (int i = 0; i < list.Count; i++) {
3167                                         ColumnHeader col = (ColumnHeader) list [i];
3168                                         if (String.Compare (key, col.Name, true) == 0)
3169                                                 return i;
3170                                 }
3171
3172                                 return -1;
3173                         }
3174 #endif
3175
3176                         public void Insert (int index, ColumnHeader value)
3177                         {
3178                                 // LAMESPEC: MSDOCS say greater than or equal to the value of the Count property
3179                                 // but it's really only greater.
3180                                 if (index < 0 || index > list.Count)
3181                                         throw new ArgumentOutOfRangeException ("index");
3182
3183                                 value.SetListView (owner);
3184                                 list.Insert (index, value);
3185                                 owner.Redraw (true);
3186                         }
3187
3188 #if NET_2_0
3189                         public void Insert (int index, string text)
3190                         {
3191                                 Insert (index, String.Empty, text);
3192                         }
3193
3194                         public void Insert (int index, string text, int width)
3195                         {
3196                                 Insert (index, String.Empty, text, width);
3197                         }
3198
3199                         public void Insert (int index, string key, string text)
3200                         {
3201                                 ColumnHeader colHeader = new ColumnHeader ();
3202                                 colHeader.Name = key;
3203                                 colHeader.Text = text;
3204                                 Insert (index, colHeader);
3205                         }
3206
3207                         public void Insert (int index, string key, string text, int width)
3208                         {
3209                                 ColumnHeader colHeader = new ColumnHeader (key, text, width, HorizontalAlignment.Left);
3210                                 Insert (index, colHeader);
3211                         }
3212
3213                         public void Insert (int index, string key, string text, int width, HorizontalAlignment textAlign, int imageIndex)
3214                         {
3215                                 ColumnHeader colHeader = new ColumnHeader (key, text, width, textAlign);
3216                                 colHeader.ImageIndex = imageIndex;
3217                                 Insert (index, colHeader);
3218                         }
3219
3220                         public void Insert (int index, string key, string text, int width, HorizontalAlignment textAlign, string imageKey)
3221                         {
3222                                 ColumnHeader colHeader = new ColumnHeader (key, text, width, textAlign);
3223                                 colHeader.ImageKey = imageKey;
3224                                 Insert (index, colHeader);
3225                         }
3226 #endif
3227
3228                         public void Insert (int index, string str, int width, HorizontalAlignment textAlign)
3229                         {
3230                                 ColumnHeader colHeader = new ColumnHeader (this.owner, str, textAlign, width);
3231                                 this.Insert (index, colHeader);
3232                         }
3233
3234                         public virtual void Remove (ColumnHeader column)
3235                         {
3236                                 // TODO: Update Column internal index ?
3237                                 list.Remove (column);
3238                                 owner.Redraw (true);
3239                         }
3240
3241 #if NET_2_0
3242                         public virtual void RemoveByKey (string key)
3243                         {
3244                                 int idx = IndexOfKey (key);
3245                                 if (idx != -1)
3246                                         RemoveAt (idx);
3247                         }
3248 #endif
3249
3250                         public virtual void RemoveAt (int index)
3251                         {
3252                                 if (index < 0 || index >= list.Count)
3253                                         throw new ArgumentOutOfRangeException ("index");
3254
3255                                 // TODO: Update Column internal index ?
3256                                 list.RemoveAt (index);
3257                                 owner.Redraw (true);
3258                         }
3259                         #endregion      // Public Methods
3260
3261
3262                 }       // ColumnHeaderCollection
3263
3264                 public class ListViewItemCollection : IList, ICollection, IEnumerable
3265                 {
3266                         private readonly ArrayList list;
3267                         private readonly ListView owner;
3268
3269                         #region Public Constructor
3270                         public ListViewItemCollection (ListView owner)
3271                         {
3272                                 list = new ArrayList ();
3273                                 this.owner = owner;
3274                         }
3275                         #endregion      // Public Constructor
3276
3277                         #region Public Properties
3278                         [Browsable (false)]
3279                         public int Count {
3280                                 get { return list.Count; }
3281                         }
3282
3283                         public bool IsReadOnly {
3284                                 get { return false; }
3285                         }
3286
3287                         public virtual ListViewItem this [int displayIndex] {
3288                                 get {
3289                                         if (displayIndex < 0 || displayIndex >= list.Count)
3290                                                 throw new ArgumentOutOfRangeException ("displayIndex");
3291                                         return (ListViewItem) list [displayIndex];
3292                                 }
3293
3294                                 set {
3295                                         if (displayIndex < 0 || displayIndex >= list.Count)
3296                                                 throw new ArgumentOutOfRangeException ("displayIndex");
3297
3298                                         if (list.Contains (value))
3299                                                 throw new ArgumentException ("An item cannot be added more than once. To add an item again, you need to clone it.", "value");
3300
3301                                         if (value.ListView != null && value.ListView != owner)
3302                                                 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");
3303
3304                                         value.Owner = owner;
3305                                         list [displayIndex] = value;
3306                                         OnChange ();
3307
3308                                         owner.Redraw (true);
3309                                 }
3310                         }
3311
3312 #if NET_2_0
3313                         public virtual ListViewItem this [string key] {
3314                                 get {
3315                                         int idx = IndexOfKey (key);
3316                                         if (idx == -1)
3317                                                 return null;
3318
3319                                         return (ListViewItem) list [idx];
3320                                 }
3321                         }
3322 #endif
3323
3324                         bool ICollection.IsSynchronized {
3325                                 get { return true; }
3326                         }
3327
3328                         object ICollection.SyncRoot {
3329                                 get { return this; }
3330                         }
3331
3332                         bool IList.IsFixedSize {
3333                                 get { return list.IsFixedSize; }
3334                         }
3335
3336                         object IList.this [int index] {
3337                                 get { return this [index]; }
3338                                 set {
3339                                         if (value is ListViewItem)
3340                                                 this [index] = (ListViewItem) value;
3341                                         else
3342                                                 this [index] = new ListViewItem (value.ToString ());
3343                                         OnChange ();
3344                                 }
3345                         }
3346                         #endregion      // Public Properties
3347
3348                         #region Public Methods
3349                         public virtual ListViewItem Add (ListViewItem value)
3350                         {
3351                                 if (list.Contains (value))
3352                                         throw new ArgumentException ("An item cannot be added more than once. To add an item again, you need to clone it.", "value");
3353
3354                                 if (value.ListView != null && value.ListView != owner)
3355                                         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");
3356
3357                                 value.Owner = owner;
3358                                 list.Add (value);
3359
3360                                 if (this.owner != null)
3361                                 {
3362                                         owner.Sort (false);
3363                                         OnChange ();
3364                                         owner.Redraw (true);
3365                                 }
3366
3367                                 return value;
3368                         }
3369
3370                         public virtual ListViewItem Add (string text)
3371                         {
3372                                 ListViewItem item = new ListViewItem (text);
3373                                 return this.Add (item);
3374                         }
3375
3376                         public virtual ListViewItem Add (string text, int imageIndex)
3377                         {
3378                                 ListViewItem item = new ListViewItem (text, imageIndex);
3379                                 return this.Add (item);
3380                         }
3381
3382 #if NET_2_0
3383                         public virtual ListViewItem Add (string text, string imageKey)
3384                         {
3385                                 ListViewItem item = new ListViewItem (text, imageKey);
3386                                 return this.Add (item);
3387                         }
3388
3389                         public virtual ListViewItem Add (string key, string text, int imageIndex)
3390                         {
3391                                 ListViewItem item = new ListViewItem (text, imageIndex);
3392                                 item.Name = key;
3393                                 return this.Add (item);
3394                         }
3395
3396                         public virtual ListViewItem Add (string key, string text, string imageKey)
3397                         {
3398                                 ListViewItem item = new ListViewItem (text, imageKey);
3399                                 item.Name = key;
3400                                 return this.Add (item);
3401                         }
3402 #endif
3403
3404                         public void AddRange (ListViewItem [] values)
3405                         {
3406                                 if (values == null)
3407                                         throw new ArgumentNullException ("Argument cannot be null!", "values");
3408
3409                                 foreach (ListViewItem item in values) {
3410                                         this.Add (item);
3411                                 }
3412                         }
3413
3414 #if NET_2_0
3415                         public void AddRange (ListViewItemCollection items)
3416                         {
3417                                 if (items == null)
3418                                         throw new ArgumentNullException ("Argument cannot be null!", "items");
3419
3420                                 ListViewItem[] itemArray = new ListViewItem[items.Count];
3421                                 items.CopyTo (itemArray,0);
3422                                 this.AddRange (itemArray);
3423                         }
3424 #endif
3425
3426                         public virtual void Clear ()
3427                         {
3428                                 owner.SetFocusedItem (null);
3429                                 owner.h_scroll.Value = owner.v_scroll.Value = 0;
3430                                 list.Clear ();
3431                                 OnChange ();
3432                                 owner.Redraw (true);
3433                         }
3434
3435                         public bool Contains (ListViewItem item)
3436                         {
3437                                 return list.Contains (item);
3438                         }
3439
3440 #if NET_2_0
3441                         public virtual bool ContainsKey (string key)
3442                         {
3443                                 return IndexOfKey (key) != -1;
3444                         }
3445 #endif
3446
3447                         public void CopyTo (Array dest, int index)
3448                         {
3449                                 list.CopyTo (dest, index);
3450                         }
3451
3452 #if NET_2_0
3453                         public ListViewItem [] Find (string key, bool searchAllSubitems)
3454                         {
3455                                 if (key == null)
3456                                         return new ListViewItem [0];
3457
3458                                 List<ListViewItem> temp_list = new List<ListViewItem> ();
3459
3460                                 for (int i = 0; i < list.Count; i++) {
3461                                         ListViewItem lvi = (ListViewItem) list [i];
3462                                         if (String.Compare (key, lvi.Name, true) == 0)
3463                                                 temp_list.Add (lvi);
3464                                 }
3465
3466                                 ListViewItem [] retval = new ListViewItem [temp_list.Count];
3467                                 temp_list.CopyTo (retval);
3468
3469                                 return retval;
3470                         }
3471 #endif
3472
3473                         public IEnumerator GetEnumerator ()
3474                         {
3475                                 return list.GetEnumerator ();
3476                         }
3477
3478                         int IList.Add (object item)
3479                         {
3480                                 int result;
3481                                 ListViewItem li;
3482
3483                                 if (item is ListViewItem) {
3484                                         li = (ListViewItem) item;
3485                                         if (list.Contains (li))
3486                                                 throw new ArgumentException ("An item cannot be added more than once. To add an item again, you need to clone it.", "item");
3487
3488                                         if (li.ListView != null && li.ListView != owner)
3489                                                 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");
3490                                 }
3491                                 else
3492                                         li = new ListViewItem (item.ToString ());
3493
3494                                 li.Owner = owner;
3495                                 result = list.Add (li);
3496                                 OnChange ();
3497                                 owner.Redraw (true);
3498
3499                                 return result;
3500                         }
3501
3502                         bool IList.Contains (object item)
3503                         {
3504                                 return list.Contains (item);
3505                         }
3506
3507                         int IList.IndexOf (object item)
3508                         {
3509                                 return list.IndexOf (item);
3510                         }
3511
3512                         void IList.Insert (int index, object item)
3513                         {
3514                                 if (item is ListViewItem)
3515                                         this.Insert (index, (ListViewItem) item);
3516                                 else
3517                                         this.Insert (index, item.ToString ());
3518                         }
3519
3520                         void IList.Remove (object item)
3521                         {
3522                                 Remove ((ListViewItem) item);
3523                         }
3524
3525                         public int IndexOf (ListViewItem item)
3526                         {
3527                                 return list.IndexOf (item);
3528                         }
3529
3530 #if NET_2_0
3531                         public virtual int IndexOfKey (string key)
3532                         {
3533                                 if (key == null || key.Length == 0)
3534                                         return -1;
3535
3536                                 for (int i = 0; i < list.Count; i++) {
3537                                         ListViewItem lvi = (ListViewItem) list [i];
3538                                         if (String.Compare (key, lvi.Name, true) == 0)
3539                                                 return i;
3540                                 }
3541
3542                                 return -1;
3543                         }
3544 #endif
3545
3546                         public ListViewItem Insert (int index, ListViewItem item)
3547                         {
3548                                 if (index < 0 || index > list.Count)
3549                                         throw new ArgumentOutOfRangeException ("index");
3550
3551                                 if (list.Contains (item))
3552                                         throw new ArgumentException ("An item cannot be added more than once. To add an item again, you need to clone it.", "item");
3553
3554                                 if (item.ListView != null && item.ListView != owner)
3555                                         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");
3556
3557                                 item.Owner = owner;
3558                                 list.Insert (index, item);
3559                                 OnChange ();
3560                                 owner.Redraw (true);
3561                                 return item;
3562                         }
3563
3564                         public ListViewItem Insert (int index, string text)
3565                         {
3566                                 return this.Insert (index, new ListViewItem (text));
3567                         }
3568
3569                         public ListViewItem Insert (int index, string text, int imageIndex)
3570                         {
3571                                 return this.Insert (index, new ListViewItem (text, imageIndex));
3572                         }
3573
3574 #if NET_2_0
3575                         public ListViewItem Insert (int index, string key, string text, int imageIndex)
3576                         {
3577                                 ListViewItem lvi = new ListViewItem (text, imageIndex);
3578                                 lvi.Name = key;
3579                                 return Insert (index, lvi);
3580                         }
3581 #endif
3582
3583                         public virtual void Remove (ListViewItem item)
3584                         {
3585                                 if (!list.Contains (item))
3586                                         return;
3587
3588                                 bool selection_changed = owner.SelectedItems.Contains (item);
3589                                 list.Remove (item);
3590                                 OnChange ();
3591                                 owner.Redraw (true);
3592                                 if (selection_changed)
3593                                         owner.OnSelectedIndexChanged (EventArgs.Empty);
3594                         }
3595
3596                         public virtual void RemoveAt (int index)
3597                         {
3598                                 if (index < 0 || index >= Count)
3599                                         throw new ArgumentOutOfRangeException ("index");
3600                                 bool selection_changed = owner.SelectedIndices.Contains (index);
3601                                 list.RemoveAt (index);
3602                                 OnChange ();
3603                                 owner.Redraw (false);
3604                                 if (selection_changed)
3605                                         owner.OnSelectedIndexChanged (EventArgs.Empty);
3606                         }
3607
3608 #if NET_2_0
3609                         public virtual void RemoveByKey (string key)
3610                         {
3611                                 int idx = IndexOfKey (key);
3612                                 if (idx != -1)
3613                                         RemoveAt (idx);
3614                         }
3615 #endif
3616
3617                         #endregion      // Public Methods
3618
3619                         internal event CollectionChangedHandler Changed;
3620
3621                         internal void Sort (IComparer comparer)
3622                         {
3623                                 list.Sort (comparer);
3624                                 OnChange ();
3625                         }
3626
3627                         internal void OnChange ()
3628                         {
3629                                 if (Changed != null)
3630                                         Changed ();
3631                         }
3632                 }       // ListViewItemCollection
3633
3634                 public class SelectedIndexCollection : IList, ICollection, IEnumerable
3635                 {
3636                         private readonly ListView owner;
3637
3638                         #region Public Constructor
3639                         public SelectedIndexCollection (ListView owner)
3640                         {
3641                                 this.owner = owner;
3642                         }
3643                         #endregion      // Public Constructor
3644
3645                         #region Public Properties
3646                         [Browsable (false)]
3647                         public int Count {
3648                                 get {
3649                                         return owner.SelectedItems.Count;
3650                                 }
3651                         }
3652
3653                         public bool IsReadOnly {
3654                                 get {
3655 #if NET_2_0
3656                                         return false;
3657 #else
3658                                         return true;
3659 #endif
3660                                 }
3661                         }
3662
3663                         public int this [int index] {
3664                                 get {
3665                                         int [] indices = GetIndices ();
3666                                         if (index < 0 || index >= indices.Length)
3667                                                 throw new ArgumentOutOfRangeException ("index");
3668                                         return indices [index];
3669                                 }
3670                         }
3671
3672                         bool ICollection.IsSynchronized {
3673                                 get { return false; }
3674                         }
3675
3676                         object ICollection.SyncRoot {
3677                                 get { return this; }
3678                         }
3679
3680                         bool IList.IsFixedSize {
3681                                 get {
3682 #if NET_2_0
3683                                         return false;
3684 #else
3685                                         return true;
3686 #endif
3687                                 }
3688                         }
3689
3690                         object IList.this [int index] {
3691                                 get { return this [index]; }
3692                                 set { throw new NotSupportedException ("SetItem operation is not supported."); }
3693                         }
3694                         #endregion      // Public Properties
3695
3696                         #region Public Methods
3697 #if NET_2_0
3698                         public int Add (int itemIndex)
3699                         {
3700                                 if (itemIndex < 0 || itemIndex >= owner.Items.Count)
3701                                         throw new ArgumentOutOfRangeException ("index");
3702
3703                                 owner.Items [itemIndex].Selected = true;
3704                                 if (!owner.IsHandleCreated)
3705                                         return 0;
3706
3707                                 return owner.SelectedItems.Count;
3708                         }
3709
3710                         public void Clear ()
3711                         {
3712                                 owner.SelectedItems.Clear ();
3713                         }
3714 #endif
3715                         public bool Contains (int selectedIndex)
3716                         {
3717                                 int [] indices = GetIndices ();
3718                                 for (int i = 0; i < indices.Length; i++) {
3719                                         if (indices [i] == selectedIndex)
3720                                                 return true;
3721                                 }
3722                                 return false;
3723                         }
3724
3725                         public void CopyTo (Array dest, int index)
3726                         {
3727                                 int [] indices = GetIndices ();
3728                                 Array.Copy (indices, 0, dest, index, indices.Length);
3729                         }
3730
3731                         public IEnumerator GetEnumerator ()
3732                         {
3733                                 int [] indices = GetIndices ();
3734                                 return indices.GetEnumerator ();
3735                         }
3736
3737                         int IList.Add (object value)
3738                         {
3739                                 throw new NotSupportedException ("Add operation is not supported.");
3740                         }
3741
3742                         void IList.Clear ()
3743                         {
3744                                 throw new NotSupportedException ("Clear operation is not supported.");
3745                         }
3746
3747                         bool IList.Contains (object selectedIndex)
3748                         {
3749                                 if (!(selectedIndex is int))
3750                                         return false;
3751                                 return Contains ((int) selectedIndex);
3752                         }
3753
3754                         int IList.IndexOf (object selectedIndex)
3755                         {
3756                                 if (!(selectedIndex is int))
3757                                         return -1;
3758                                 return IndexOf ((int) selectedIndex);
3759                         }
3760
3761                         void IList.Insert (int index, object value)
3762                         {
3763                                 throw new NotSupportedException ("Insert operation is not supported.");
3764                         }
3765
3766                         void IList.Remove (object value)
3767                         {
3768                                 throw new NotSupportedException ("Remove operation is not supported.");
3769                         }
3770
3771                         void IList.RemoveAt (int index)
3772                         {
3773                                 throw new NotSupportedException ("RemoveAt operation is not supported.");
3774                         }
3775
3776                         public int IndexOf (int selectedIndex)
3777                         {
3778                                 int [] indices = GetIndices ();
3779                                 for (int i = 0; i < indices.Length; i++) {
3780                                         if (indices [i] == selectedIndex)
3781                                                 return i;
3782                                 }
3783                                 return -1;
3784                         }
3785
3786 #if NET_2_0
3787                         public void Remove (int itemIndex)
3788                         {
3789                                 if (itemIndex < 0 || itemIndex >= owner.Items.Count)
3790                                         throw new ArgumentOutOfRangeException ("itemIndex");
3791
3792                                 owner.Items [itemIndex].Selected = false;
3793                         }
3794 #endif
3795                         #endregion      // Public Methods
3796
3797                         private int [] GetIndices ()
3798                         {
3799                                 ArrayList selected_items = owner.SelectedItems.List;
3800                                 int [] indices = new int [selected_items.Count];
3801                                 for (int i = 0; i < selected_items.Count; i++) {
3802                                         ListViewItem item = (ListViewItem) selected_items [i];
3803                                         indices [i] = item.Index;
3804                                 }
3805                                 return indices;
3806                         }
3807                 }       // SelectedIndexCollection
3808
3809                 public class SelectedListViewItemCollection : IList, ICollection, IEnumerable
3810                 {
3811                         private readonly ListView owner;
3812                         private ArrayList list;
3813
3814                         #region Public Constructor
3815                         public SelectedListViewItemCollection (ListView owner)
3816                         {
3817                                 this.owner = owner;
3818                                 this.owner.Items.Changed += new CollectionChangedHandler (
3819                                         ItemsCollection_Changed);
3820                         }
3821                         #endregion      // Public Constructor
3822
3823                         #region Public Properties
3824                         [Browsable (false)]
3825                         public int Count {
3826                                 get {
3827                                         if (!owner.IsHandleCreated)
3828                                                 return 0;
3829                                         return List.Count;
3830                                 }
3831                         }
3832
3833                         public bool IsReadOnly {
3834                                 get { return true; }
3835                         }
3836
3837                         public ListViewItem this [int index] {
3838                                 get {
3839                                         ArrayList selected_items = List;
3840                                         if (!owner.IsHandleCreated || index < 0 || index >= selected_items.Count)
3841                                                 throw new ArgumentOutOfRangeException ("index");
3842                                         return (ListViewItem) selected_items [index];
3843                                 }
3844                         }
3845
3846 #if NET_2_0
3847                         public virtual ListViewItem this [string key] {
3848                                 get {
3849                                         int idx = IndexOfKey (key);
3850                                         if (idx == -1)
3851                                                 return null;
3852
3853                                         return (ListViewItem) List [idx];
3854                                 }
3855                         }
3856 #endif
3857
3858                         bool ICollection.IsSynchronized {
3859                                 get { return false; }
3860                         }
3861
3862                         object ICollection.SyncRoot {
3863                                 get { return this; }
3864                         }
3865
3866                         bool IList.IsFixedSize {
3867                                 get { return true; }
3868                         }
3869
3870                         object IList.this [int index] {
3871                                 get { return this [index]; }
3872                                 set { throw new NotSupportedException ("SetItem operation is not supported."); }
3873                         }
3874                         #endregion      // Public Properties
3875
3876                         #region Public Methods
3877                         public void Clear ()
3878                         {
3879                                 if (!owner.IsHandleCreated)
3880                                         return;
3881
3882                                 foreach (ListViewItem item in List)
3883                                         item.Selected = false;
3884                         }
3885
3886                         public bool Contains (ListViewItem item)
3887                         {
3888                                 if (!owner.IsHandleCreated)
3889                                         return false;
3890                                 return List.Contains (item);
3891                         }
3892
3893 #if NET_2_0
3894                         public virtual bool ContainsKey (string key)
3895                         {
3896                                 return IndexOfKey (key) != -1;
3897                         }
3898 #endif
3899
3900                         public void CopyTo (Array dest, int index)
3901                         {
3902                                 if (!owner.IsHandleCreated)
3903                                         return;
3904                                 List.CopyTo (dest, index);
3905                         }
3906
3907                         public IEnumerator GetEnumerator ()
3908                         {
3909                                 if (!owner.IsHandleCreated)
3910                                         return (new ListViewItem [0]).GetEnumerator ();
3911                                 return List.GetEnumerator ();
3912                         }
3913
3914                         int IList.Add (object value)
3915                         {
3916                                 throw new NotSupportedException ("Add operation is not supported.");
3917                         }
3918
3919                         bool IList.Contains (object item)
3920                         {
3921                                 if (!(item is ListViewItem))
3922                                         return false;
3923                                 return Contains ((ListViewItem) item);
3924                         }
3925
3926                         int IList.IndexOf (object item)
3927                         {
3928                                 if (!(item is ListViewItem))
3929                                         return -1;
3930                                 return IndexOf ((ListViewItem) item);
3931                         }
3932
3933                         void IList.Insert (int index, object value)
3934                         {
3935                                 throw new NotSupportedException ("Insert operation is not supported.");
3936                         }
3937
3938                         void IList.Remove (object value)
3939                         {
3940                                 throw new NotSupportedException ("Remove operation is not supported.");
3941                         }
3942
3943                         void IList.RemoveAt (int index)
3944                         {
3945                                 throw new NotSupportedException ("RemoveAt operation is not supported.");
3946                         }
3947
3948                         public int IndexOf (ListViewItem item)
3949                         {
3950                                 if (!owner.IsHandleCreated)
3951                                         return -1;
3952                                 return List.IndexOf (item);
3953                         }
3954
3955 #if NET_2_0
3956                         public virtual int IndexOfKey (string key)
3957                         {
3958                                 if (!owner.IsHandleCreated || key == null || key.Length == 0)
3959                                         return -1;
3960
3961                                 ArrayList selected_items = List;
3962                                 for (int i = 0; i < selected_items.Count; i++) {
3963                                         ListViewItem item = (ListViewItem) selected_items [i];
3964                                         if (String.Compare (item.Name, key, true) == 0)
3965                                                 return i;
3966                                 }
3967
3968                                 return -1;
3969                         }
3970 #endif
3971                         #endregion      // Public Methods
3972
3973                         internal ArrayList List {
3974                                 get {
3975                                         if (list == null) {
3976                                                 list = new ArrayList ();
3977                                                 foreach (ListViewItem item in owner.Items) {
3978                                                         if (item.Selected)
3979                                                                 list.Add (item);
3980                                                 }
3981                                         }
3982                                         return list;
3983                                 }
3984                         }
3985
3986                         internal void Reset ()
3987                         {
3988                                 // force re-population of list
3989                                 list = null;
3990                         }
3991
3992                         private void ItemsCollection_Changed ()
3993                         {
3994                                 Reset ();
3995                         }
3996                 }       // SelectedListViewItemCollection
3997
3998                 internal delegate void CollectionChangedHandler ();
3999
4000                 #endregion // Subclasses
4001 #if NET_2_0
4002                 protected override void OnResize (EventArgs e)
4003                 {
4004                         base.OnResize (e);
4005                 }
4006
4007                 protected override void OnMouseLeave (EventArgs e)
4008                 {
4009                         base.OnMouseLeave (e);
4010                 }
4011
4012                 //
4013                 // ColumnReorder event
4014                 //
4015                 static object ColumnReorderedEvent = new object ();
4016                 public event ColumnReorderedEventHandler ColumnReordered {
4017                         add { Events.AddHandler (ColumnReorderedEvent, value); }
4018                         remove { Events.RemoveHandler (ColumnReorderedEvent, value); }
4019                 }
4020
4021                 protected virtual void OnColumnReordered (ColumnReorderedEventArgs e)
4022                 {
4023                         ColumnReorderedEventHandler creh = (ColumnReorderedEventHandler) (Events [ColumnReorderedEvent]);
4024
4025                         if (creh != null)
4026                                 creh (this, e);
4027                 }
4028
4029                 //
4030                 // ColumnWidthChanged
4031                 //
4032                 static object ColumnWidthChangedEvent = new object ();
4033                 public event ColumnWidthChangedEventHandler ColumnWidthChanged {
4034                         add { Events.AddHandler (ColumnWidthChangedEvent, value); }
4035                         remove { Events.RemoveHandler (ColumnWidthChangedEvent, value); }
4036                 }
4037
4038                 protected virtual void OnColumnWidthChanged (ColumnWidthChangedEventArgs e)
4039                 {
4040                         ColumnWidthChangedEventHandler eh = (ColumnWidthChangedEventHandler) (Events[ColumnWidthChangedEvent]);
4041                         if (eh != null)
4042                                 eh (this, e);
4043                 }
4044
4045                 void RaiseColumnWidthChanged (int resize_column)
4046                 {
4047                         ColumnWidthChangedEventArgs n = new ColumnWidthChangedEventArgs (resize_column);
4048
4049                         OnColumnWidthChanged (n);
4050                 }
4051
4052                 //
4053                 // ColumnWidthChanging
4054                 //
4055                 static object ColumnWidthChangingEvent = new object ();
4056                 public event ColumnWidthChangingEventHandler ColumnWidthChanging {
4057                         add { Events.AddHandler (ColumnWidthChangingEvent, value); }
4058                         remove { Events.RemoveHandler (ColumnWidthChangingEvent, value); }
4059                 }
4060
4061                 protected virtual void OnColumnWidthChanging (ColumnWidthChangingEventArgs e)
4062                 {
4063                         ColumnWidthChangingEventHandler cwceh = (ColumnWidthChangingEventHandler) (Events[ColumnWidthChangingEvent]);
4064                         if (cwceh != null)
4065                                 cwceh (this, e);
4066                 }
4067
4068                 //
4069                 // 2.0 profile based implementation
4070                 //
4071                 bool CanProceedWithResize (ColumnHeader col, int width)
4072                 {
4073                         ColumnWidthChangingEventHandler cwceh = (ColumnWidthChangingEventHandler) (Events[ColumnWidthChangingEvent]);
4074                         if (cwceh == null)
4075                                 return true;
4076
4077                         ColumnWidthChangingEventArgs changing = new ColumnWidthChangingEventArgs (col.Index, width);
4078                         cwceh (this, changing);
4079                         return !changing.Cancel;
4080                 }
4081 #else
4082                 //
4083                 // 1.0 profile based implementation
4084                 //
4085                 bool CanProceedWithResize (ColumnHeader col, int width)
4086                 {
4087                         return true;
4088                 }
4089
4090                 void RaiseColumnWidthChanged (int resize_column)
4091                 {
4092                 }
4093 #endif
4094         }
4095 }