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