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 //
  27 // TODO:
  28 //   - Feedback for item activation, change in cursor types as mouse moves.
  29 //   - HideSelection
  30 //   - LabelEdit
  31 //   - Drag and drop
  32
  33
  34 // NOT COMPLETE
  35
  36
  37 using System.Collections;
  38 using System.ComponentModel;
  39 using System.ComponentModel.Design;
  40 using System.Drawing;
  41 using System.Runtime.InteropServices;
  42 using System.Globalization;
  43
  44 namespace System.Windows.Forms
  45 {
  46         [DefaultEvent ("SelectedIndexChanged")]
  47         [DefaultProperty ("Items")]
  48         [Designer ("System.Windows.Forms.Design.ListViewDesigner, " + Consts.AssemblySystem_Design, "System.ComponentModel.Design.IDesigner")]
  49         public class ListView : Control
  50         {
  51                 private ItemActivation activation = ItemActivation.Standard;
  52                 private ListViewAlignment alignment = ListViewAlignment.Top;
  53                 private bool allow_column_reorder = false;
  54                 private bool auto_arrange = true;
  55                 private bool check_boxes = false;
  56                 private CheckedIndexCollection checked_indices;
  57                 private CheckedListViewItemCollection checked_items;
  58                 private ColumnHeaderCollection columns;
  59                 internal ListViewItem focused_item;
  60                 private bool full_row_select = false;
  61                 private bool grid_lines = false;
  62                 private ColumnHeaderStyle header_style = ColumnHeaderStyle.Clickable;
  63                 private bool hide_selection = true;
  64                 private bool hover_selection = false;
  65                 private IComparer item_sorter;
  66                 private ListViewItemCollection items;
  67                 private bool label_edit = false;
  68                 private bool label_wrap = true;
  69                 private bool multiselect = true;
  70                 private bool scrollable = true;
  71                 private SelectedIndexCollection selected_indices;
  72                 private SelectedListViewItemCollection selected_items;
  73                 private SortOrder sort_order = SortOrder.None;
  74                 private ImageList state_image_list;
  75                 private bool updating = false;
  76                 private View view = View.LargeIcon;
  77                 private int layout_wd;    // We might draw more than our client area
  78                 private int layout_ht;    // therefore we need to have these two.
  79                 //private TextBox editor;   // Used for editing an item text
  80                 HeaderControl header_control;
  81                 internal ItemControl item_control;
  82                 internal ScrollBar h_scroll; // used for scrolling horizontally
  83                 internal ScrollBar v_scroll; // used for scrolling vertically
  84                 internal int h_marker;          // Position markers for scrolling
  85                 internal int v_marker;
  86                 private int keysearch_tickcnt;
  87                 private string keysearch_text;
  88                 static private readonly int keysearch_keydelay = 1000;
  89                 private int[] reordered_column_indices;
  90
  91                 // internal variables
  92                 internal ImageList large_image_list;
  93                 internal ImageList small_image_list;
  94                 internal Size text_size = Size.Empty;
  95
  96                 #region Events
  97                 public event LabelEditEventHandler AfterLabelEdit;
  98
  99                 [Browsable (false)]
 100                 [EditorBrowsable (EditorBrowsableState.Never)]
 101                 public new event EventHandler BackgroundImageChanged {
 102                         add { base.BackgroundImageChanged += value; }
 103                         remove { base.BackgroundImageChanged -= value; }
 104                 }
 105
 106                 public event LabelEditEventHandler BeforeLabelEdit;
 107                 public event ColumnClickEventHandler ColumnClick;
 108                 public event EventHandler ItemActivate;
 109                 public event ItemCheckEventHandler ItemCheck;
 110                 public event ItemDragEventHandler ItemDrag;
 111
 112                 [Browsable (false)]
 113                 [EditorBrowsable (EditorBrowsableState.Never)]
 114                 public new event PaintEventHandler Paint {
 115                         add { base.Paint += value; }
 116                         remove { base.Paint -= value; }
 117                 }
 118
 119                 public event EventHandler SelectedIndexChanged;
 120
 121                 [Browsable (false)]
 122                 [EditorBrowsable (EditorBrowsableState.Never)]
 123                 public new event EventHandler TextChanged {
 124                         add { base.TextChanged += value; }
 125                         remove { base.TextChanged -= value; }
 126                 }
 127
 128                 #endregion // Events
 129
 130                 #region Public Constructors
 131                 public ListView ()
 132                 {
 133                         background_color = ThemeEngine.Current.ColorWindow;
 134                         checked_indices = new CheckedIndexCollection (this);
 135                         checked_items = new CheckedListViewItemCollection (this);
 136                         columns = new ColumnHeaderCollection (this);
 137                         foreground_color = SystemColors.WindowText;
 138                         items = new ListViewItemCollection (this);
 139                         selected_indices = new SelectedIndexCollection (this);
 140                         selected_items = new SelectedListViewItemCollection (this);
 141
 142                         border_style = BorderStyle.Fixed3D;
 143
 144                         header_control = new HeaderControl (this);
 145                         header_control.Visible = false;
 146                         item_control = new ItemControl (this);
 147                         item_control.Visible = true;
 148
 149                         h_scroll = new HScrollBar ();
 150                         v_scroll = new VScrollBar ();
 151                         h_marker = v_marker = 0;
 152                         keysearch_tickcnt = 0;
 153
 154                         // scroll bars are disabled initially
 155                         h_scroll.Visible = false;
 156                         h_scroll.ValueChanged += new EventHandler(HorizontalScroller);
 157                         v_scroll.Visible = false;
 158                         v_scroll.ValueChanged += new EventHandler(VerticalScroller);
 159
 160                         // event handlers
 161                         base.KeyDown += new KeyEventHandler(ListView_KeyDown);
 162                         base.Paint += new PaintEventHandler (ListView_Paint);
 163                         SizeChanged += new EventHandler (ListView_SizeChanged);
 164
 165                         this.SetStyle (ControlStyles.UserPaint | ControlStyles.StandardClick, false);
 166                 }
 167                 #endregion      // Public Constructors
 168
 169                 #region Private Internal Properties
 170                 internal Size CheckBoxSize {
 171                         get {
 172                                 if (this.check_boxes) {
 173                                         if (this.state_image_list != null)
 174                                                 return this.state_image_list.ImageSize;
 175                                         else
 176                                                 return ThemeEngine.Current.ListViewCheckBoxSize;
 177                                 }
 178                                 return Size.Empty;
 179                         }
 180                 }
 181
 182                 internal bool CanMultiselect {
 183                         get {
 184                                 if (multiselect && (XplatUI.State.ModifierKeys & (Keys.Control | Keys.Shift)) != 0)
 185                                         return true;
 186                                 else
 187                                         return false;
 188                         }
 189                 }
 190
 191                 #endregion      // Private Internal Properties
 192
 193                 #region  Protected Properties
 194                 protected override CreateParams CreateParams {
 195                         get { return base.CreateParams; }
 196                 }
 197
 198                 protected override Size DefaultSize {
 199                         get { return ThemeEngine.Current.ListViewDefaultSize; }
 200                 }
 201                 #endregion      // Protected Properties
 202
 203                 #region Public Instance Properties
 204                 [DefaultValue (ItemActivation.Standard)]
 205                 public ItemActivation Activation {
 206                         get { return activation; }
 207                         set {
 208                                 if (value != ItemActivation.Standard && value != ItemActivation.OneClick &&
 209                                         value != ItemActivation.TwoClick) {
 210                                         throw new InvalidEnumArgumentException (string.Format
 211                                                 ("Enum argument value '{0}' is not valid for Activation", value));
 212                                 }
 213
 214                                 activation = value;
 215                         }
 216                 }
 217
 218                 [DefaultValue (ListViewAlignment.Top)]
 219                 [Localizable (true)]
 220                 public ListViewAlignment Alignment {
 221                         get { return alignment; }
 222                         set {
 223                                 if (value != ListViewAlignment.Default && value != ListViewAlignment.Left &&
 224                                         value != ListViewAlignment.SnapToGrid && value != ListViewAlignment.Top) {
 225                                         throw new InvalidEnumArgumentException (string.Format
 226                                                 ("Enum argument value '{0}' is not valid for Alignment", value));
 227                                 }
 228
 229                                 if (this.alignment != value) {
 230                                         alignment = value;
 231                                         // alignment does not matter in Details/List views
 232                                         if (this.view == View.LargeIcon ||
 233                                             this.View == View.SmallIcon)
 234                                                 this.Redraw (true);
 235                                 }
 236                         }
 237                 }
 238
 239                 [DefaultValue (false)]
 240                 public bool AllowColumnReorder {
 241                         get { return allow_column_reorder; }
 242                         set { allow_column_reorder = value; }
 243                 }
 244
 245                 [DefaultValue (true)]
 246                 public bool AutoArrange {
 247                         get { return auto_arrange; }
 248                         set {
 249                                 if (auto_arrange != value) {
 250                                         auto_arrange = value;
 251                                         // autoarrange does not matter in Details/List views
 252                                         if (this.view == View.LargeIcon || this.View == View.SmallIcon)
 253                                                 this.Redraw (true);
 254                                 }
 255                         }
 256                 }
 257
 258                 public override Color BackColor {
 259                         get {
 260                                 if (background_color.IsEmpty)
 261                                         return ThemeEngine.Current.ColorWindow;
 262                                 else
 263                                         return background_color;
 264                         }
 265                         set { background_color = value; }
 266                 }
 267
 268                 [Browsable (false)]
 269                 [EditorBrowsable (EditorBrowsableState.Never)]
 270                 public override Image BackgroundImage {
 271                         get { return background_image; }
 272                         set {
 273                                 if (value == background_image)
 274                                         return;
 275
 276                                 background_image = value;
 277                                 OnBackgroundImageChanged (EventArgs.Empty);
 278                         }
 279                 }
 280
 281                 [DefaultValue (BorderStyle.Fixed3D)]
 282                 [DispId (-504)]
 283                 public BorderStyle BorderStyle {
 284                         get { return InternalBorderStyle; }
 285                         set { InternalBorderStyle = value; }
 286                 }
 287
 288                 [DefaultValue (false)]
 289                 public bool CheckBoxes {
 290                         get { return check_boxes; }
 291                         set {
 292                                 if (check_boxes != value) {
 293                                         check_boxes = value;
 294                                         this.Redraw (true);
 295                                 }
 296                         }
 297                 }
 298
 299                 [Browsable (false)]
 300                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 301                 public CheckedIndexCollection CheckedIndices {
 302                         get { return checked_indices; }
 303                 }
 304
 305                 [Browsable (false)]
 306                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 307                 public CheckedListViewItemCollection CheckedItems {
 308                         get { return checked_items; }
 309                 }
 310
 311                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]
 312                 [Localizable (true)]
 313                 [MergableProperty (false)]
 314                 public ColumnHeaderCollection Columns {
 315                         get { return columns; }
 316                 }
 317
 318                 [Browsable (false)]
 319                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 320                 public ListViewItem FocusedItem {
 321                         get {
 322                                 if (focused_item == null && Focused && items.Count > 0)
 323                                         focused_item = items [0];
 324                                 return focused_item;
 325                         }
 326                 }
 327
 328                 public override Color ForeColor {
 329                         get {
 330                                 if (foreground_color.IsEmpty)
 331                                         return ThemeEngine.Current.ColorWindowText;
 332                                 else
 333                                         return foreground_color;
 334                         }
 335                         set { foreground_color = value; }
 336                 }
 337
 338                 [DefaultValue (false)]
 339                 public bool FullRowSelect {
 340                         get { return full_row_select; }
 341                         set { full_row_select = value; }
 342                 }
 343
 344                 [DefaultValue (false)]
 345                 public bool GridLines {
 346                         get { return grid_lines; }
 347                         set {
 348                                 if (grid_lines != value) {
 349                                         grid_lines = value;
 350                                         this.Redraw (false);
 351                                 }
 352                         }
 353                 }
 354
 355                 [DefaultValue (ColumnHeaderStyle.Clickable)]
 356                 public ColumnHeaderStyle HeaderStyle {
 357                         get { return header_style; }
 358                         set {
 359                                 if (header_style == value)
 360                                         return;
 361
 362                                 switch (value) {
 363                                 case ColumnHeaderStyle.Clickable:
 364                                 case ColumnHeaderStyle.Nonclickable:
 365                                 case ColumnHeaderStyle.None:
 366                                         break;
 367                                 default:
 368                                         throw new InvalidEnumArgumentException (string.Format
 369                                                 ("Enum argument value '{0}' is not valid for ColumnHeaderStyle", value));
 370                                 }
 371
 372                                 header_style = value;
 373                                 if (view == View.Details)
 374                                         Redraw (true);
 375                         }
 376                 }
 377
 378                 [DefaultValue (true)]
 379                 public bool HideSelection {
 380                         get { return hide_selection; }
 381                         set {
 382                                 if (hide_selection != value) {
 383                                         hide_selection = value;
 384                                         this.Redraw (false);
 385                                 }
 386                         }
 387                 }
 388
 389                 [DefaultValue (false)]
 390                 public bool HoverSelection {
 391                         get { return hover_selection; }
 392                         set { hover_selection = value; }
 393                 }
 394
 395                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]
 396                 [Localizable (true)]
 397                 [MergableProperty (false)]
 398                 public ListViewItemCollection Items {
 399                         get { return items; }
 400                 }
 401
 402                 [DefaultValue (false)]
 403                 public bool LabelEdit {
 404                         get { return label_edit; }
 405                         set { label_edit = value; }
 406                 }
 407
 408                 [DefaultValue (true)]
 409                 [Localizable (true)]
 410                 public bool LabelWrap {
 411                         get { return label_wrap; }
 412                         set {
 413                                 if (label_wrap != value) {
 414                                         label_wrap = value;
 415                                         this.Redraw (true);
 416                                 }
 417                         }
 418                 }
 419
 420                 [DefaultValue (null)]
 421                 public ImageList LargeImageList {
 422                         get { return large_image_list; }
 423                         set {
 424                                 large_image_list = value;
 425                                 this.Redraw (true);
 426                         }
 427                 }
 428
 429                 [Browsable (false)]
 430                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 431                 public IComparer ListViewItemSorter {
 432                         get { return item_sorter; }
 433                         set { item_sorter = value; }
 434                 }
 435
 436                 [DefaultValue (true)]
 437                 public bool MultiSelect {
 438                         get { return multiselect; }
 439                         set { multiselect = value; }
 440                 }
 441
 442                 [DefaultValue (true)]
 443                 public bool Scrollable {
 444                         get { return scrollable; }
 445                         set {
 446                                 if (scrollable != value) {
 447                                         scrollable = value;
 448                                         this.Redraw (true);
 449                                 }
 450                         }
 451                 }
 452
 453                 [Browsable (false)]
 454                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 455                 public SelectedIndexCollection SelectedIndices {
 456                         get { return selected_indices; }
 457                 }
 458
 459                 [Browsable (false)]
 460                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 461                 public SelectedListViewItemCollection SelectedItems {
 462                         get { return selected_items; }
 463                 }
 464
 465                 [DefaultValue (null)]
 466                 public ImageList SmallImageList {
 467                         get { return small_image_list; }
 468                         set {
 469                                 small_image_list = value;
 470                                 this.Redraw (true);
 471                         }
 472                 }
 473
 474                 [DefaultValue (SortOrder.None)]
 475                 public SortOrder Sorting {
 476                         get { return sort_order; }
 477                         set {
 478                                 if (value != SortOrder.Ascending && value != SortOrder.Descending  &&
 479                                         value != SortOrder.None) {
 480                                         throw new InvalidEnumArgumentException (string.Format
 481                                                 ("Enum argument value '{0}' is not valid for Sorting", value));
 482                                 }
 483
 484                                 if (sort_order != value)  {
 485                                         sort_order = value;
 486                                         this.Redraw (false);
 487                                 }
 488                         }
 489                 }
 490
 491                 [DefaultValue (null)]
 492                 public ImageList StateImageList {
 493                         get { return state_image_list; }
 494                         set {
 495                                 state_image_list = value;
 496                                 this.Redraw (true);
 497                         }
 498                 }
 499
 500                 [Bindable (false)]
 501                 [Browsable (false)]
 502                 [EditorBrowsable (EditorBrowsableState.Never)]
 503                 public override string Text {
 504                         get { return text; }
 505                         set {
 506                                 if (value == text)
 507                                         return;
 508
 509                                 text = value;
 510                                 this.Redraw (true);
 511
 512                                 OnTextChanged (EventArgs.Empty);
 513                         }
 514                 }
 515
 516                 [Browsable (false)]
 517                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 518                 public ListViewItem TopItem {
 519                         get {
 520                                 // there is no item
 521                                 if (this.items.Count == 0)
 522                                         return null;
 523                                 // if contents are not scrolled
 524                                 // it is the first item
 525                                 else if (h_marker == 0 && v_marker == 0)
 526                                         return this.items [0];
 527                                 // do a hit test for the scrolled position
 528                                 else {
 529                                         foreach (ListViewItem item in this.items) {
 530                                                 if (item.Bounds.X >= 0 && item.Bounds.Y >= 0)
 531                                                         return item;
 532                                         }
 533                                         return null;
 534                                 }
 535                         }
 536                 }
 537
 538                 [DefaultValue (View.LargeIcon)]
 539                 public View View {
 540                         get { return view; }
 541                         set {
 542                                 if (value != View.Details && value != View.LargeIcon  &&
 543                                         value != View.List  && value != View.SmallIcon  ) {
 544                                         throw new InvalidEnumArgumentException (string.Format
 545                                                 ("Enum argument value '{0}' is not valid for View", value));
 546                                 }
 547
 548                                 if (view != value) {
 549                                         h_scroll.Value = v_scroll.Value = 0;
 550                                         view = value;
 551                                         Redraw (true);
 552                                 }
 553                         }
 554                 }
 555                 #endregion      // Public Instance Properties
 556
 557                 #region Internal Methods Properties
 558
 559                 internal int FirstVisibleIndex {
 560                         get {
 561                                 // there is no item
 562                                 if (this.items.Count == 0)
 563                                         return 0;
 564
 565                                 if (h_marker == 0 && v_marker == 0)
 566                                         return 0;
 567
 568                                 foreach (ListViewItem item in this.items) {
 569                                         if (item.Bounds.Right >= 0 && item.Bounds.Bottom >= 0)
 570                                                 return item.Index;
 571                                 }
 572                                 return 0;
 573
 574                         }
 575                 }
 576
 577
 578                 internal int LastVisibleIndex {
 579                         get {
 580                                 for (int i = FirstVisibleIndex; i < Items.Count; i++) {
 581                                         if (Items[i].Bounds.Y > ClientRectangle.Bottom)
 582                                                         return i -1;
 583                                 }
 584
 585                                 return Items.Count - 1;
 586                         }
 587                 }
 588
 589                 internal int TotalWidth {
 590                         get { return Math.Max (this.Width, this.layout_wd); }
 591                 }
 592
 593                 internal int TotalHeight {
 594                         get { return Math.Max (this.Height, this.layout_ht); }
 595                 }
 596
 597                 internal void Redraw (bool recalculate)
 598                 {
 599                         // Avoid calculations when control is being updated
 600                         if (this.updating)
 601                                 return;
 602
 603                         if (recalculate)
 604                                 CalculateListView (this.alignment);
 605
 606                         Refresh ();
 607                 }
 608
 609                 internal Size GetChildColumnSize (int index)
 610                 {
 611                         Size ret_size = Size.Empty;
 612                         ColumnHeader col = this.columns [index];
 613
 614                         if (col.Width == -2) { // autosize = max(items, columnheader)
 615                                 Size size = Size.Ceiling (this.DeviceContext.MeasureString
 616                                                           (col.Text, this.Font));
 617                                 ret_size = BiggestItem (index);
 618                                 if (size.Width > ret_size.Width)
 619                                         ret_size = size;
 620                         }
 621                         else { // -1 and all the values < -2 are put under one category
 622                                 ret_size = BiggestItem (index);
 623                                 // fall back to empty columns' width if no subitem is available for a column
 624                                 if (ret_size.IsEmpty) {
 625                                         ret_size.Width = ThemeEngine.Current.ListViewEmptyColumnWidth;
 626                                         if (col.Text.Length > 0)
 627                                                 ret_size.Height = Size.Ceiling (this.DeviceContext.MeasureString
 628                                                                                 (col.Text, this.Font)).Height;
 629                                         else
 630                                                 ret_size.Height = this.Font.Height;
 631                                 }
 632                         }
 633
 634                         // adjust the size for icon and checkbox for 0th column
 635                         if (index == 0) {
 636                                 ret_size.Width += (this.CheckBoxSize.Width + 4);
 637                                 if (this.small_image_list != null)
 638                                         ret_size.Width += this.small_image_list.ImageSize.Width;
 639                         }
 640                         return ret_size;
 641                 }
 642
 643                 // Returns the size of biggest item text in a column.
 644                 private Size BiggestItem (int col)
 645                 {
 646                         Size temp = Size.Empty;
 647                         Size ret_size = Size.Empty;
 648
 649                         // 0th column holds the item text, we check the size of
 650                         // the various subitems falling in that column and get
 651                         // the biggest one's size.
 652                         foreach (ListViewItem item in items) {
 653                                 if (col >= item.SubItems.Count)
 654                                         continue;
 655
 656                                 temp = Size.Ceiling (this.DeviceContext.MeasureString
 657                                                      (item.SubItems [col].Text, this.Font));
 658                                 if (temp.Width > ret_size.Width)
 659                                         ret_size = temp;
 660                         }
 661
 662                         // adjustment for space
 663                         if (!ret_size.IsEmpty)
 664                                 ret_size.Width += 4;
 665
 666                         return ret_size;
 667                 }
 668
 669                 // Sets the size of the biggest item text as per the view
 670                 private void CalcTextSize ()
 671                 {
 672                         // clear the old value
 673                         text_size = Size.Empty;
 674
 675                         if (items.Count == 0)
 676                                 return;
 677
 678                         text_size = BiggestItem (0);
 679
 680                         if (view == View.LargeIcon && this.label_wrap) {
 681                                 Size temp = Size.Empty;
 682                                 if (this.check_boxes)
 683                                         temp.Width += 2 * this.CheckBoxSize.Width;
 684                                 if (large_image_list != null)
 685                                         temp.Width += large_image_list.ImageSize.Width;
 686                                 if (temp.Width == 0)
 687                                         temp.Width = 43;
 688                                 // wrapping is done for two lines only
 689                                 if (text_size.Width > temp.Width) {
 690                                         text_size.Width = temp.Width;
 691                                         text_size.Height *= 2;
 692                                 }
 693                         }
 694                         else if (view == View.List) {
 695                                 // in list view max text shown in determined by the
 696                                 // control width, even if scolling is enabled.
 697                                 int max_wd = this.Width - (this.CheckBoxSize.Width - 2);
 698                                 if (this.small_image_list != null)
 699                                         max_wd -= this.small_image_list.ImageSize.Width;
 700
 701                                 if (text_size.Width > max_wd)
 702                                         text_size.Width = max_wd;
 703                         }
 704
 705                         // we do the default settings, if we have got 0's
 706                         if (text_size.Height <= 0)
 707                                 text_size.Height = this.Font.Height;
 708                         if (text_size.Width <= 0)
 709                                 text_size.Width = this.Width;
 710
 711                         // little adjustment
 712                         text_size.Width += 4;
 713                         text_size.Height += 2;
 714                 }
 715
 716                 private void Scroll (ScrollBar scrollbar, int delta)
 717                 {
 718                         if (delta == 0 || !scrollbar.Visible)
 719                                 return;
 720
 721                         int max;
 722                         if (scrollbar == h_scroll)
 723                                 max = h_scroll.Maximum - item_control.Width;
 724                         else
 725                                 max = v_scroll.Maximum - item_control.Height;
 726
 727                         int val = scrollbar.Value + delta;
 728                         if (val > max)
 729                                 val = max;
 730                         else if (val < scrollbar.Minimum)
 731                                 val = scrollbar.Minimum;
 732                         scrollbar.Value = val;
 733                 }
 734
 735                 private void CalculateScrollBars ()
 736                 {
 737                         Rectangle client_area = ClientRectangle;
 738
 739                         if (!this.scrollable || this.items.Count <= 0) {
 740                                 h_scroll.Visible = false;
 741                                 v_scroll.Visible = false;
 742                                 return;
 743                         }
 744
 745                         // making a scroll bar visible might make
 746                         // other scroll bar visible
 747                         if (layout_wd > client_area.Right) {
 748                                 h_scroll.Visible = true;
 749                                 if ((layout_ht + h_scroll.Height) > client_area.Bottom)
 750                                         v_scroll.Visible = true;
 751                                 else
 752                                         v_scroll.Visible = false;
 753                         } else if (layout_ht > client_area.Bottom) {
 754                                 v_scroll.Visible = true;
 755                                 if ((layout_wd + v_scroll.Width) > client_area.Right)
 756                                         h_scroll.Visible = true;
 757                                 else
 758                                         h_scroll.Visible = false;
 759                         } else {
 760                                 h_scroll.Visible = false;
 761                                 v_scroll.Visible = false;
 762                         }
 763
 764                         item_control.Height = ClientRectangle.Height - header_control.Height;
 765
 766                         if (h_scroll.Visible) {
 767                                 h_scroll.Location = new Point (client_area.X, client_area.Bottom - h_scroll.Height);
 768                                 h_scroll.Minimum = 0;
 769
 770                                 // if v_scroll is visible, adjust the maximum of the
 771                                 // h_scroll to account for the width of v_scroll
 772                                 if (v_scroll.Visible) {
 773                                         h_scroll.Maximum = layout_wd + v_scroll.Width;
 774                                         h_scroll.Width = client_area.Width - v_scroll.Width;
 775                                 }
 776                                 else {
 777                                         h_scroll.Maximum = layout_wd;
 778                                         h_scroll.Width = client_area.Width;
 779                                 }
 780
 781                                 h_scroll.LargeChange = client_area.Width;
 782                                 h_scroll.SmallChange = Font.Height;
 783                                 item_control.Height -= h_scroll.Height;
 784                         }
 785
 786                         if (header_control.Visible)
 787                                 header_control.Width = ClientRectangle.Width;
 788                         item_control.Width = ClientRectangle.Width;
 789
 790                         if (v_scroll.Visible) {
 791                                 v_scroll.Location = new Point (client_area.Right - v_scroll.Width, client_area.Y);
 792                                 v_scroll.Minimum = 0;
 793
 794                                 // if h_scroll is visible, adjust the maximum of the
 795                                 // v_scroll to account for the height of h_scroll
 796                                 if (h_scroll.Visible) {
 797                                         v_scroll.Maximum = layout_ht + h_scroll.Height;
 798                                         v_scroll.Height = client_area.Height; // - h_scroll.Height already done
 799                                 } else {
 800                                         v_scroll.Maximum = layout_ht;
 801                                         v_scroll.Height = client_area.Height;
 802                                 }
 803
 804                                 v_scroll.LargeChange = client_area.Height;
 805                                 v_scroll.SmallChange = Font.Height;
 806                                 if (header_control.Visible)
 807                                         header_control.Width -= v_scroll.Width;
 808                                 item_control.Width -= v_scroll.Width;
 809                         }
 810                 }
 811
 812                 ColumnHeader GetReorderedColumn (int index)
 813                 {
 814                         if (reordered_column_indices == null)
 815                                 return Columns [index];
 816                         else
 817                                 return Columns [reordered_column_indices [index]];
 818                 }
 819
 820                 void ReorderColumn (ColumnHeader col, int index)
 821                 {
 822                         if (reordered_column_indices == null) {
 823                                 reordered_column_indices = new int [Columns.Count];
 824                                 for (int i = 0; i < Columns.Count; i++)
 825                                         reordered_column_indices [i] = i;
 826                         }
 827
 828                         if (reordered_column_indices [index] == col.Index)
 829                                 return;
 830
 831                         int[] curr = reordered_column_indices;
 832                         int[] result = new int [Columns.Count];
 833                         int curr_idx = 0;
 834                         for (int i = 0; i < Columns.Count; i++) {
 835                                 if (curr_idx < Columns.Count && curr [curr_idx] == col.Index)
 836                                         curr_idx++;
 837
 838                                 if (i == index)
 839                                         result [i] = col.Index;
 840                                 else
 841                                         result [i] = curr [curr_idx++];
 842                         }
 843
 844                         reordered_column_indices = result;
 845                         LayoutDetails ();
 846                         header_control.Invalidate ();
 847                         item_control.Invalidate ();
 848                 }
 849
 850                 Size LargeIconItemSize {
 851                         get {
 852                                 int image_w = LargeImageList == null ? 12 : LargeImageList.ImageSize.Width;
 853                                 int image_h = LargeImageList == null ? 2 : LargeImageList.ImageSize.Height;
 854                                 int w = CheckBoxSize.Width + 2 + Math.Max (text_size.Width, image_w);
 855                                 int h = text_size.Height + 2 + Math.Max (CheckBoxSize.Height, image_h);
 856                                 return new Size (w, h);
 857                         }
 858                 }
 859
 860                 Size SmallIconItemSize {
 861                         get {
 862                                 int image_w = SmallImageList == null ? 0 : SmallImageList.ImageSize.Width;
 863                                 int image_h = SmallImageList == null ? 0 : SmallImageList.ImageSize.Height;
 864                                 int w = text_size.Width + 2 + CheckBoxSize.Width + image_w;
 865                                 int h = Math.Max (text_size.Height, Math.Max (CheckBoxSize.Height, image_h));
 866                                 return new Size (w, h);
 867                         }
 868                 }
 869
 870                 int rows;
 871                 int cols;
 872                 ListViewItem[,] item_matrix;
 873
 874                 void LayoutIcons (bool large_icons, bool left_aligned, int x_spacing, int y_spacing)
 875                 {
 876                         header_control.Visible = false;
 877                         header_control.Size = Size.Empty;
 878                         item_control.Location = Point.Empty;
 879
 880                         if (items.Count == 0)
 881                                 return;
 882
 883                         Size sz = large_icons ? LargeIconItemSize : SmallIconItemSize;
 884
 885                         Rectangle area = ClientRectangle;
 886
 887                         if (left_aligned) {
 888                                 rows = (int) Math.Floor ((double)(area.Height - h_scroll.Height + y_spacing) / (double)(sz.Height + y_spacing));
 889                                 if (rows <= 0)
 890                                         rows = 1;
 891                                 cols = (int) Math.Ceiling ((double)items.Count / (double)rows);
 892                         } else {
 893                                 cols = (int) Math.Floor ((double)(area.Width - v_scroll.Width + x_spacing) / (double)(sz.Width + x_spacing));
 894                                 if (cols <= 0)
 895                                         cols = 1;
 896                                 rows = (int) Math.Ceiling ((double)items.Count / (double)cols);
 897                         }
 898
 899                         layout_ht = rows * (sz.Height + y_spacing) - y_spacing;
 900                         layout_wd = cols * (sz.Width + x_spacing) - x_spacing;
 901                         item_matrix = new ListViewItem [rows, cols];
 902                         int row = 0;
 903                         int col = 0;
 904                         foreach (ListViewItem item in items) {
 905                                 int x = col * (sz.Width + x_spacing);
 906                                 int y = row * (sz.Height + y_spacing);
 907                                 item.Location = new Point (x, y);
 908                                 item.Layout ();
 909                                 item.row = row;
 910                                 item.col = col;
 911                                 item_matrix [row, col] = item;
 912                                 if (left_aligned) {
 913                                         if (++row == rows) {
 914                                                 row = 0;
 915                                                 col++;
 916                                         }
 917                                 } else {
 918                                         if (++col == cols) {
 919                                                 col = 0;
 920                                                 row++;
 921                                         }
 922                                 }
 923                         }
 924
 925                         item_control.Size = new Size (layout_wd, layout_ht);
 926                 }
 927
 928                 void LayoutHeader ()
 929                 {
 930                         if (columns.Count == 0 || header_style == ColumnHeaderStyle.None) {
 931                                 header_control.Visible = false;
 932                                 header_control.Size = Size.Empty;
 933                                 return;
 934                         }
 935
 936                         int x = 0;
 937                         for (int i = 0; i < Columns.Count; i++) {
 938                                 ColumnHeader col = GetReorderedColumn (i);
 939                                 col.X = x;
 940                                 col.Y = 0;
 941                                 col.CalcColumnHeader ();
 942                                 x += col.Wd;
 943                         }
 944
 945                         header_control.Width = x;
 946                         header_control.Height = columns [0].Ht;
 947                         header_control.Visible = true;
 948                 }
 949
 950                 void LayoutDetails ()
 951                 {
 952                         LayoutHeader ();
 953
 954                         item_control.Location = new Point (0, header_control.Height);
 955
 956                         int y = 0;
 957                         if (items.Count > 0) {
 958                                 foreach (ListViewItem item in items) {
 959                                         item.Layout ();
 960                                         item.Location = new Point (0, y);
 961                                         y += item.Bounds.Height + 2;
 962                                 }
 963
 964                                 // some space for bottom gridline
 965                                 if (grid_lines)
 966                                         y += 2;
 967                         }
 968
 969                         layout_wd = Math.Max (header_control.Width, item_control.Width);
 970                         layout_ht = y + header_control.Height;
 971                 }
 972
 973                 private void CalculateListView (ListViewAlignment align)
 974                 {
 975                         CalcTextSize ();
 976
 977                         switch (view) {
 978                         case View.Details:
 979                                 LayoutDetails ();
 980                                 break;
 981
 982                         case View.SmallIcon:
 983                                 LayoutIcons (false, alignment == ListViewAlignment.Left, 4, 2);
 984                                 break;
 985
 986                         case View.LargeIcon:
 987                                 LayoutIcons (true, alignment == ListViewAlignment.Left,
 988                                              ThemeEngine.Current.ListViewHorizontalSpacing,
 989                                              ThemeEngine.Current.ListViewVerticalSpacing);
 990                                 break;
 991
 992                         case View.List:
 993                                 LayoutIcons (false, true, 4, 2);
 994                                 break;
 995                         }
 996
 997                         CalculateScrollBars ();
 998                 }
 999
1000                 internal void UpdateSelection (ListViewItem item)
1001                 {
1002                         if (item.Selected) {
1003
1004                                 if (!CanMultiselect && SelectedItems.Count > 0) {
1005                                         SelectedItems.Clear ();
1006                                         SelectedIndices.list.Clear ();
1007                                 }
1008
1009                                 if (!SelectedItems.Contains (item)) {
1010                                         SelectedItems.list.Add (item);
1011                                         SelectedIndices.list.Add (item.Index);
1012                                 }
1013                         } else {
1014                                 SelectedItems.list.Remove (item);
1015                                 SelectedIndices.list.Remove (item.Index);
1016                         }
1017                 }
1018
1019                 private bool KeySearchString (KeyEventArgs ke)
1020                 {
1021                         int current_tickcnt = Environment.TickCount;
1022                         if (keysearch_tickcnt > 0 && current_tickcnt - keysearch_tickcnt > keysearch_keydelay) {
1023                                 keysearch_text = string.Empty;
1024                         }
1025
1026                         keysearch_text += (char) ke.KeyData;
1027                         keysearch_tickcnt = current_tickcnt;
1028
1029                         int start = FocusedItem == null ? 0 : FocusedItem.Index;
1030                         int i = start;
1031                         while (true) {
1032                                 if (CultureInfo.CurrentCulture.CompareInfo.IsPrefix (Items[i].Text, keysearch_text,
1033                                         CompareOptions.IgnoreCase)) {
1034                                         SetFocusedItem (Items [i]);
1035                                         items [i].Selected = true;
1036                                         EnsureVisible (i);
1037                                         break;
1038                                 }
1039                                 i = (i + 1  < Items.Count) ? i+1 : 0;
1040
1041                                 if (i == start)
1042                                         break;
1043                         }
1044                         return true;
1045                 }
1046
1047                 int GetAdjustedIndex (Keys key)
1048                 {
1049                         int result = -1;
1050
1051                         if (View == View.Details) {
1052                                 if (key == Keys.Up)
1053                                         result = FocusedItem.Index - 1;
1054                                 else if (key == Keys.Down) {
1055                                         result = FocusedItem.Index + 1;
1056                                         if (result == items.Count)
1057                                                 result = -1;
1058                                 }
1059                                 return result;
1060                         }
1061
1062                         int row = FocusedItem.row;
1063                         int col = FocusedItem.col;
1064
1065                         switch (key) {
1066                         case Keys.Left:
1067                                 if (col == 0)
1068                                         return -1;
1069                                 return item_matrix [row, col - 1].Index;
1070
1071                         case Keys.Right:
1072                                 if (col == (cols - 1))
1073                                         return -1;
1074                                 while (item_matrix [row, col + 1] == null)
1075                                        row--;
1076                                 return item_matrix [row, col + 1].Index;
1077
1078                         case Keys.Up:
1079                                 if (row == 0)
1080                                         return -1;
1081                                 return item_matrix [row - 1, col].Index;
1082
1083                         case Keys.Down:
1084                                 if (row == (rows - 1))
1085                                         return -1;
1086                                 while (item_matrix [row + 1, col] == null)
1087                                        col--;
1088                                 return item_matrix [row + 1, col].Index;
1089
1090                         default:
1091                                 return -1;
1092                         }
1093                 }
1094
1095                 ListViewItem selection_start;
1096
1097                 private void SelectItems (ArrayList sel_items)
1098                 {
1099                         SelectedItems.Clear ();
1100                         SelectedIndices.list.Clear ();
1101                         foreach (ListViewItem item in sel_items)
1102                                 item.Selected = true;
1103                 }
1104
1105                 private void UpdateMultiSelection (int index)
1106                 {
1107                         bool shift_pressed = (XplatUI.State.ModifierKeys & Keys.Shift) != 0;
1108                         bool ctrl_pressed = (XplatUI.State.ModifierKeys & Keys.Control) != 0;
1109                         ListViewItem item = items [index];
1110
1111                         if (shift_pressed && selection_start != null) {
1112                                 ArrayList list = new ArrayList ();
1113                                 int start = Math.Min (selection_start.Index, index);
1114                                 int end = Math.Max (selection_start.Index, index);
1115                                 if (View == View.Details) {
1116                                         for (int i = start; i <= end; i++)
1117                                                 list.Add (items [i]);
1118                                 } else {
1119                                         int left = Math.Min (items [start].col, items [end].col);
1120                                         int right = Math.Max (items [start].col, items [end].col);
1121                                         int top = Math.Min (items [start].row, items [end].row);
1122                                         int bottom = Math.Max (items [start].row, items [end].row);
1123                                         foreach (ListViewItem curr in items)
1124                                                 if (curr.row >= top && curr.row <= bottom &&
1125                                                     curr.col >= left && curr.col <= right)
1126                                                         list.Add (curr);
1127                                 }
1128                                 SelectItems (list);
1129                         } else if (!ctrl_pressed) {
1130                                 SelectedItems.Clear ();
1131                                 SelectedIndices.list.Clear ();
1132                                 item.Selected = true;
1133                                 selection_start = item;
1134                         }
1135                 }
1136
1137                 private void ListView_KeyDown (object sender, KeyEventArgs ke)
1138                 {
1139                         if (ke.Handled || Items.Count == 0)
1140                                 return;
1141
1142                         int index = -1;
1143                         ke.Handled = true;
1144
1145                         switch (ke.KeyCode) {
1146
1147                         case Keys.End:
1148                                 index = Items.Count - 1;
1149                                 break;
1150
1151                         case Keys.Home:
1152                                 index = 0;
1153                                 break;
1154
1155                         case Keys.Left:
1156                         case Keys.Right:
1157                         case Keys.Up:
1158                         case Keys.Down:
1159                                 index = GetAdjustedIndex (ke.KeyCode);
1160                                 break;
1161
1162                         default:
1163                                 ke.Handled = KeySearchString (ke);
1164                                 return;
1165                         }
1166
1167                         if (index == -1)
1168                                 return;
1169
1170                         if (MultiSelect)
1171                                 UpdateMultiSelection (index);
1172                         else
1173                                 items [index].Selected = true;
1174
1175                         SetFocusedItem (items [index]);
1176                         EnsureVisible (index);
1177                 }
1178
1179
1180                 internal class ItemControl : Control {
1181
1182                         ListView owner;
1183                         ListViewItem clicked_item;
1184                         ListViewItem last_clicked_item;
1185                         bool hover_processed = false;
1186
1187                         public ItemControl (ListView owner)
1188                         {
1189                                 this.owner = owner;
1190                                 DoubleClick += new EventHandler(ItemsDoubleClick);
1191                                 KeyDown += new KeyEventHandler (ItemsKeyDown);
1192                                 KeyUp += new KeyEventHandler (ItemsKeyUp);
1193                                 MouseDown += new MouseEventHandler(ItemsMouseDown);
1194                                 MouseMove += new MouseEventHandler(ItemsMouseMove);
1195                                 MouseHover += new EventHandler(ItemsMouseHover);
1196                                 MouseUp += new MouseEventHandler(ItemsMouseUp);
1197                                 MouseWheel += new MouseEventHandler(ItemsMouseWheel);
1198                                 Paint += new PaintEventHandler (ItemsPaint);
1199                         }
1200
1201                         void ItemsDoubleClick (object sender, EventArgs e)
1202                         {
1203                                 if (owner.activation == ItemActivation.Standard && owner.ItemActivate != null)
1204                                         owner.ItemActivate (this, e);
1205                         }
1206
1207                         void ItemsKeyDown (object sender, KeyEventArgs args)
1208                         {
1209                                 owner.OnKeyDown (args);
1210                         }
1211
1212                         void ItemsKeyUp (object sender, KeyEventArgs args)
1213                         {
1214                                 owner.OnKeyUp (args);
1215                         }
1216
1217                         private void ItemsMouseDown (object sender, MouseEventArgs me)
1218                         {
1219                                 if (owner.items.Count == 0)
1220                                         return;
1221
1222                                 Point pt = new Point (me.X, me.Y);
1223                                 foreach (ListViewItem item in owner.items) {
1224                                         if (item.CheckRectReal.Contains (pt)) {
1225                                                 CheckState curr_state = item.Checked ?  CheckState.Checked : CheckState.Unchecked;
1226                                                 item.Checked = !item.Checked;
1227
1228                                                 CheckState new_state = item.Checked ?  CheckState.Checked : CheckState.Unchecked;
1229
1230                                                 // Raise the ItemCheck event
1231                                                 ItemCheckEventArgs ice = new ItemCheckEventArgs (item.Index, curr_state, new_state);
1232                                                 owner.OnItemCheck (ice);
1233                                                 break;
1234                                         }
1235
1236                                         if (owner.View == View.Details && !owner.FullRowSelect) {
1237                                                 if (item.GetBounds (ItemBoundsPortion.Label).Contains (pt)) {
1238                                                         clicked_item = item;
1239                                                         break;
1240                                                 }
1241                                         } else {
1242                                                 if (item.Bounds.Contains (pt)) {
1243                                                         clicked_item = item;
1244                                                         break;
1245                                                 }
1246                                         }
1247                                 }
1248
1249                                 owner.SetFocusedItem (clicked_item);
1250
1251                                 if (clicked_item != null) {
1252                                         bool changed = !clicked_item.Selected;
1253                                         if (owner.MultiSelect && (XplatUI.State.ModifierKeys & Keys.Control) == 0)
1254                                                 owner.UpdateMultiSelection (clicked_item.Index);
1255                                         else
1256                                                 clicked_item.Selected = true;
1257
1258                                         if (changed)
1259                                                 owner.OnSelectedIndexChanged (EventArgs.Empty);
1260
1261                                         // Raise double click if the item was clicked. On MS the
1262                                         // double click is only raised if you double click an item
1263                                         if (me.Clicks > 1 && clicked_item != null)
1264                                                 owner.OnDoubleClick (EventArgs.Empty);
1265                                         else if (me.Clicks == 1 && clicked_item != null)
1266                                                 owner.OnClick (EventArgs.Empty);
1267                                 } else if (owner.selected_indices.Count > 0) {
1268                                         // Raise the event if there was at least one item
1269                                         // selected and the user click on a dead area (unselecting all)
1270                                         owner.SelectedItems.Clear ();
1271                                         owner.SelectedIndices.list.Clear ();
1272                                         owner.OnSelectedIndexChanged (EventArgs.Empty);
1273                                 }
1274                         }
1275
1276                         private void ItemsMouseMove (object sender, MouseEventArgs me)
1277                         {
1278                                 if (owner.HoverSelection && hover_processed) {
1279
1280                                         Point pt = PointToClient (Control.MousePosition);
1281                                         ListViewItem item = owner.GetItemAt (pt.X, pt.Y);
1282                                         if (item == null || item.Selected)
1283                                                 return;
1284
1285                                         hover_processed = false;
1286                                         XplatUI.ResetMouseHover (Handle);
1287                                 }
1288                         }
1289
1290
1291                         private void ItemsMouseHover (object sender, EventArgs e)
1292                         {
1293                                 if (Capture || !owner.HoverSelection)
1294                                         return;
1295
1296                                 hover_processed = true;
1297                                 Point pt = PointToClient (Control.MousePosition);
1298                                 ListViewItem item = owner.GetItemAt (pt.X, pt.Y);
1299
1300                                 if (item == null)
1301                                         return;
1302
1303                                 item.Selected = true;
1304                                 owner.OnSelectedIndexChanged (new EventArgs ());
1305                         }
1306
1307                         private void ItemsMouseUp (object sender, MouseEventArgs me)
1308                         {
1309                                 Capture = false;
1310                                 if (owner.Items.Count == 0)
1311                                         return;
1312
1313                                 Point pt = new Point (me.X, me.Y);
1314
1315                                 Rectangle rect = Rectangle.Empty;
1316                                 if (clicked_item != null) {
1317                                         if (owner.view == View.Details && !owner.full_row_select)
1318                                                 rect = clicked_item.GetBounds (ItemBoundsPortion.Label);
1319                                         else
1320                                                 rect = clicked_item.Bounds;
1321
1322                                         if (rect.Contains (pt)) {
1323                                                 switch (owner.activation) {
1324                                                 case ItemActivation.OneClick:
1325                                                         owner.OnItemActivate (EventArgs.Empty);
1326                                                         break;
1327
1328                                                 case ItemActivation.TwoClick:
1329                                                         if (last_clicked_item == clicked_item) {
1330                                                                 owner.OnItemActivate (EventArgs.Empty);
1331                                                                 last_clicked_item = null;
1332                                                         } else
1333                                                                 last_clicked_item = clicked_item;
1334                                                         break;
1335                                                 default:
1336                                                         // DoubleClick activation is handled in another handler
1337                                                         break;
1338                                                 }
1339                                         }
1340                                 }
1341
1342                                 clicked_item = null;
1343                         }
1344
1345                         private void ItemsMouseWheel (object sender, MouseEventArgs me)
1346                         {
1347                                 if (owner.Items.Count == 0)
1348                                         return;
1349
1350                                 int lines = me.Delta / 120;
1351
1352                                 if (lines == 0)
1353                                         return;
1354
1355                                 switch (owner.View) {
1356                                 case View.Details:
1357                                 case View.SmallIcon:
1358                                         owner.Scroll (owner.v_scroll, -owner.Items [0].Bounds.Height * SystemInformation.MouseWheelScrollLines * lines);
1359                                         break;
1360                                 case View.LargeIcon:
1361                                         owner.Scroll (owner.v_scroll, -(owner.Items [0].Bounds.Height + ThemeEngine.Current.ListViewVerticalSpacing)  * lines);
1362                                         break;
1363                                 case View.List:
1364                                         owner.Scroll (owner.h_scroll, -owner.Items [0].Bounds.Width * lines);
1365                                         break;
1366                                 }
1367                         }
1368
1369                         private void ItemsPaint (object sender, PaintEventArgs pe)
1370                         {
1371                                 ThemeEngine.Current.DrawListViewItems (pe.Graphics, pe.ClipRectangle, owner);
1372                         }
1373                 }
1374
1375                 private void ListView_Paint (object sender, PaintEventArgs pe)
1376                 {
1377                         if (Width <= 0 || Height <=  0 || !Visible || updating)
1378                                 return;
1379
1380                         CalculateScrollBars ();
1381                 }
1382
1383                 private void ListView_SizeChanged (object sender, EventArgs e)
1384                 {
1385                         CalculateListView (alignment);
1386                 }
1387
1388                 private void SetFocusedItem (ListViewItem item)
1389                 {
1390                         if (focused_item != null)
1391                                 focused_item.Focused = false;
1392
1393                         if (item != null)
1394                                 item.Focused = true;
1395
1396                         focused_item = item;
1397                 }
1398
1399                 private void HorizontalScroller (object sender, EventArgs e)
1400                 {
1401                         // Avoid unnecessary flickering, when button is
1402                         // kept pressed at the end
1403                         if (h_marker != h_scroll.Value) {
1404
1405                                 int pixels =  h_marker - h_scroll.Value;
1406
1407                                 h_marker = h_scroll.Value;
1408                                 if (header_control.Visible)
1409                                         XplatUI.ScrollWindow (header_control.Handle, pixels, 0, false);
1410
1411                                 XplatUI.ScrollWindow (item_control.Handle, pixels, 0, false);
1412                         }
1413                 }
1414
1415                 private void VerticalScroller (object sender, EventArgs e)
1416                 {
1417                         // Avoid unnecessary flickering, when button is
1418                         // kept pressed at the end
1419                         if (v_marker != v_scroll.Value) {
1420                                 int pixels =  v_marker - v_scroll.Value;
1421                                 Rectangle area = item_control.ClientRectangle;
1422                                 v_marker = v_scroll.Value;
1423                                 XplatUI.ScrollWindow (item_control.Handle, area, 0, pixels, false);
1424                         }
1425                 }
1426                 #endregion      // Internal Methods Properties
1427
1428                 #region Protected Methods
1429                 protected override void CreateHandle ()
1430                 {
1431                         base.CreateHandle ();
1432                 }
1433
1434                 protected override void Dispose (bool disposing)
1435                 {
1436                         if (disposing) {
1437                                 h_scroll.Dispose ();
1438                                 v_scroll.Dispose ();
1439
1440                                 large_image_list = null;
1441                                 small_image_list = null;
1442                                 state_image_list = null;
1443                         }
1444
1445                         base.Dispose (disposing);
1446                 }
1447
1448                 protected override bool IsInputKey (Keys keyData)
1449                 {
1450                         switch (keyData) {
1451                         case Keys.Up:
1452                         case Keys.Down:
1453                         case Keys.PageUp:
1454                         case Keys.PageDown:
1455                         case Keys.Right:
1456                         case Keys.Left:
1457                         case Keys.End:
1458                         case Keys.Home:
1459                                 return true;
1460
1461                         default:
1462                                 break;
1463                         }
1464
1465                         return base.IsInputKey (keyData);
1466                 }
1467
1468                 protected virtual void OnAfterLabelEdit (LabelEditEventArgs e)
1469                 {
1470                         if (AfterLabelEdit != null)
1471                                 AfterLabelEdit (this, e);
1472                 }
1473
1474                 protected virtual void OnBeforeLabelEdit (LabelEditEventArgs e)
1475                 {
1476                         if (BeforeLabelEdit != null)
1477                                 BeforeLabelEdit (this, e);
1478                 }
1479
1480                 protected virtual void OnColumnClick (ColumnClickEventArgs e)
1481                 {
1482                         if (ColumnClick != null)
1483                                 ColumnClick (this, e);
1484                 }
1485
1486                 protected override void OnEnabledChanged (EventArgs e)
1487                 {
1488                         base.OnEnabledChanged (e);
1489                 }
1490
1491                 protected override void OnFontChanged (EventArgs e)
1492                 {
1493                         base.OnFontChanged (e);
1494                         Redraw (true);
1495                 }
1496
1497                 protected override void OnHandleCreated (EventArgs e)
1498                 {
1499                         base.OnHandleCreated (e);
1500                         SuspendLayout ();
1501                         Controls.AddImplicit (header_control);
1502                         Controls.AddImplicit (item_control);
1503                         Controls.AddImplicit (this.v_scroll);
1504                         Controls.AddImplicit (this.h_scroll);
1505                         ResumeLayout ();
1506                 }
1507
1508                 protected override void OnHandleDestroyed (EventArgs e)
1509                 {
1510                         base.OnHandleDestroyed (e);
1511                 }
1512
1513                 protected virtual void OnItemActivate (EventArgs e)
1514                 {
1515                         if (ItemActivate != null)
1516                                 ItemActivate (this, e);
1517                 }
1518
1519                 protected virtual void OnItemCheck (ItemCheckEventArgs ice)
1520                 {
1521                         if (ItemCheck != null)
1522                                 ItemCheck (this, ice);
1523                 }
1524
1525                 protected virtual void OnItemDrag (ItemDragEventArgs e)
1526                 {
1527                         if (ItemDrag != null)
1528                                 ItemDrag (this, e);
1529                 }
1530
1531                 protected virtual void OnSelectedIndexChanged (EventArgs e)
1532                 {
1533                         if (SelectedIndexChanged != null)
1534                                 SelectedIndexChanged (this, e);
1535                 }
1536
1537                 protected override void OnSystemColorsChanged (EventArgs e)
1538                 {
1539                         base.OnSystemColorsChanged (e);
1540                 }
1541
1542                 protected void RealizeProperties ()
1543                 {
1544                         // FIXME: TODO
1545                 }
1546
1547                 protected void UpdateExtendedStyles ()
1548                 {
1549                         // FIXME: TODO
1550                 }
1551
1552                 protected override void WndProc (ref Message m)
1553                 {
1554                         base.WndProc (ref m);
1555                 }
1556                 #endregion // Protected Methods
1557
1558                 #region Public Instance Methods
1559                 public void ArrangeIcons ()
1560                 {
1561                         ArrangeIcons (this.alignment);
1562                 }
1563
1564                 public void ArrangeIcons (ListViewAlignment alignment)
1565                 {
1566                         // Icons are arranged only if view is set to LargeIcon or SmallIcon
1567                         if (view == View.LargeIcon || view == View.SmallIcon) {
1568                                 this.CalculateListView (alignment);
1569                                 // we have done the calculations already
1570                                 this.Redraw (false);
1571                         }
1572                 }
1573
1574                 public void BeginUpdate ()
1575                 {
1576                         // flag to avoid painting
1577                         updating = true;
1578                 }
1579
1580                 public void Clear ()
1581                 {
1582                         columns.Clear ();
1583                         items.Clear (); // Redraw (true) called here
1584                 }
1585
1586                 public void EndUpdate ()
1587                 {
1588                         // flag to avoid painting
1589                         updating = false;
1590
1591                         // probably, now we need a redraw with recalculations
1592                         this.Redraw (true);
1593                 }
1594
1595                 public void EnsureVisible (int index)
1596                 {
1597                         if (index < 0 || index >= items.Count || scrollable == false)
1598                                 return;
1599
1600                         Rectangle view_rect = item_control.ClientRectangle;
1601                         Rectangle bounds = items [index].Bounds;
1602
1603                         if (view_rect.Contains (bounds))
1604                                 return;
1605
1606                         if (bounds.Left < 0)
1607                                 h_scroll.Value += bounds.Left;
1608                         else if (bounds.Right > view_rect.Right)
1609                                 h_scroll.Value += (bounds.Right - view_rect.Right);
1610
1611                         if (bounds.Top < 0)
1612                                 v_scroll.Value += bounds.Top;
1613                         else if (bounds.Bottom > view_rect.Bottom)
1614                                 v_scroll.Value += (bounds.Bottom - view_rect.Bottom);
1615                 }
1616
1617                 public ListViewItem GetItemAt (int x, int y)
1618                 {
1619                         foreach (ListViewItem item in items) {
1620                                 if (item.Bounds.Contains (x, y))
1621                                         return item;
1622                         }
1623                         return null;
1624                 }
1625
1626                 public Rectangle GetItemRect (int index)
1627                 {
1628                         return GetItemRect (index, ItemBoundsPortion.Entire);
1629                 }
1630
1631                 public Rectangle GetItemRect (int index, ItemBoundsPortion portion)
1632                 {
1633                         if (index < 0 || index >= items.Count)
1634                                 throw new IndexOutOfRangeException ("Invalid Index");
1635
1636                         return items [index].GetBounds (portion);
1637                 }
1638
1639                 public void Sort ()
1640                 {
1641                         if (sort_order != SortOrder.None)
1642                                 items.list.Sort (item_sorter);
1643
1644                         if (sort_order == SortOrder.Descending)
1645                                 items.list.Reverse ();
1646
1647                         this.Redraw (true);
1648                 }
1649
1650                 public override string ToString ()
1651                 {
1652                         int count = this.Items.Count;
1653
1654                         if (count == 0)
1655                                 return string.Format ("System.Windows.Forms.ListView, Items.Count: 0");
1656                         else
1657                                 return string.Format ("System.Windows.Forms.ListView, Items.Count: {0}, Items[0]: {1}", count, this.Items [0].ToString ());
1658                 }
1659                 #endregion      // Public Instance Methods
1660
1661
1662                 #region Subclasses
1663
1664                 class HeaderControl : Control {
1665
1666                         ListView owner;
1667                         bool column_resize_active = false;
1668                         ColumnHeader resize_column;
1669                         ColumnHeader clicked_column;
1670                         ColumnHeader drag_column;
1671                         int drag_x;
1672                         int drag_to_index = -1;
1673
1674                         public HeaderControl (ListView owner)
1675                         {
1676                                 this.owner = owner;
1677                                 MouseDown += new MouseEventHandler (HeaderMouseDown);
1678                                 MouseMove += new MouseEventHandler (HeaderMouseMove);
1679                                 MouseUp += new MouseEventHandler (HeaderMouseUp);
1680                                 Paint += new PaintEventHandler (HeaderPaint);
1681                         }
1682
1683                         private ColumnHeader ColumnAtX (int x)
1684                         {
1685                                 Point pt = new Point (x, 0);
1686                                 ColumnHeader result = null;
1687                                 foreach (ColumnHeader col in owner.Columns) {
1688                                         if (col.Rect.Contains (pt)) {
1689                                                 result = col;
1690                                                 break;
1691                                         }
1692                                 }
1693                                 return result;
1694                         }
1695
1696                         private int GetReorderedIndex (ColumnHeader col)
1697                         {
1698                                 if (owner.reordered_column_indices == null)
1699                                         return col.Index;
1700                                 else
1701                                         for (int i = 0; i < owner.Columns.Count; i++)
1702                                                 if (owner.reordered_column_indices [i] == col.Index)
1703                                                         return i;
1704                                 throw new Exception ("Column index missing from reordered array");
1705                         }
1706
1707                         private void HeaderMouseDown (object sender, MouseEventArgs me)
1708                         {
1709                                 if (resize_column != null) {
1710                                         column_resize_active = true;
1711                                         Capture = true;
1712                                         return;
1713                                 }
1714
1715                                 clicked_column = ColumnAtX (me.X + owner.h_marker);
1716
1717                                 if (clicked_column != null) {
1718                                         Capture = true;
1719                                         if (owner.AllowColumnReorder) {
1720                                                 drag_x = me.X;
1721                                                 drag_column = (ColumnHeader) (clicked_column as ICloneable).Clone ();
1722                                                 drag_column.column_rect = clicked_column.Rect;
1723                                                 drag_to_index = GetReorderedIndex (clicked_column);
1724                                         }
1725                                         clicked_column.pressed = true;
1726                                         Rectangle bounds = clicked_column.Rect;
1727                                         bounds.X -= owner.h_marker;
1728                                         Invalidate (bounds);
1729                                         return;
1730                                 }
1731                         }
1732
1733                         private void HeaderMouseMove (object sender, MouseEventArgs me)
1734                         {
1735                                 Point pt = new Point (me.X + owner.h_marker, me.Y);
1736
1737                                 if (column_resize_active)  {
1738                                         resize_column.Width = pt.X - resize_column.X;
1739                                         if (resize_column.Width < 0)
1740                                                 resize_column.Width = 0;
1741                                         return;
1742                                 }
1743
1744                                 resize_column = null;
1745
1746                                 if (clicked_column != null) {
1747                                         if (owner.AllowColumnReorder) {
1748                                                 Rectangle r;
1749
1750                                                 r = drag_column.column_rect;
1751                                                 r.X = clicked_column.Rect.X + me.X - drag_x;
1752                                                 drag_column.column_rect = r;
1753
1754                                                 int x = me.X + owner.h_marker;
1755                                                 ColumnHeader over = ColumnAtX (x);
1756                                                 if (over == null)
1757                                                         drag_to_index = owner.Columns.Count;
1758                                                 else if (x < over.X + over.Width / 2)
1759                                                         drag_to_index = GetReorderedIndex (over);
1760                                                 else
1761                                                         drag_to_index = GetReorderedIndex (over) + 1;
1762                                                 Invalidate ();
1763                                         } else {
1764                                                 ColumnHeader over = ColumnAtX (me.X + owner.h_marker);
1765                                                 bool pressed = clicked_column.pressed;
1766                                                 clicked_column.pressed = over == clicked_column;
1767                                                 if (clicked_column.pressed ^ pressed) {
1768                                                         Rectangle bounds = clicked_column.Rect;
1769                                                         bounds.X -= owner.h_marker;
1770                                                         Invalidate (bounds);
1771                                                 }
1772                                         }
1773                                         return;
1774                                 }
1775
1776                                 for (int i = 0; i < owner.Columns.Count; i++) {
1777                                         Rectangle zone = owner.Columns [i].Rect;
1778                                         zone.X = zone.Right - 5;
1779                                         zone.Width = 10;
1780                                         if (zone.Contains (pt)) {
1781                                                 resize_column = owner.Columns [i];
1782                                                 break;
1783                                         }
1784                                 }
1785
1786                                 if (resize_column == null)
1787                                         Cursor = Cursors.Default;
1788                                 else
1789                                         Cursor = Cursors.VSplit;
1790                         }
1791
1792                         void HeaderMouseUp (object sender, MouseEventArgs me)
1793                         {
1794                                 Capture = false;
1795
1796                                 if (column_resize_active) {
1797                                         column_resize_active = false;
1798                                         resize_column = null;
1799                                         Cursor = Cursors.Default;
1800                                         return;
1801                                 }
1802
1803                                 if (clicked_column != null && clicked_column.pressed) {
1804                                         clicked_column.pressed = false;
1805                                         Rectangle bounds = clicked_column.Rect;
1806                                         bounds.X -= owner.h_marker;
1807                                         Invalidate (bounds);
1808                                         owner.OnColumnClick (new ColumnClickEventArgs (clicked_column.Index));
1809                                 }
1810
1811                                 if (drag_column != null && owner.AllowColumnReorder) {
1812                                         drag_column = null;
1813                                         if (drag_to_index > GetReorderedIndex (clicked_column))
1814                                                 drag_to_index--;
1815                                         if (owner.GetReorderedColumn (drag_to_index) != clicked_column)
1816                                                 owner.ReorderColumn (clicked_column, drag_to_index);
1817                                         drag_to_index = -1;
1818                                         Invalidate ();
1819                                 }
1820
1821                                 clicked_column = null;
1822                         }
1823
1824                         void HeaderPaint (object sender, PaintEventArgs pe)
1825                         {
1826                                 if (Width <= 0 || Height <=  0 || !Visible || owner.updating)
1827                                         return;
1828
1829                                 Theme theme = ThemeEngine.Current;
1830                                 theme.DrawListViewHeader (pe.Graphics, pe.ClipRectangle, this.owner);
1831
1832                                 if (drag_column == null)
1833                                         return;
1834
1835                                 int target_x;
1836                                 if (drag_to_index == owner.Columns.Count)
1837                                         target_x = owner.GetReorderedColumn (drag_to_index - 1).Rect.Right - owner.h_marker;
1838                                 else
1839                                         target_x = owner.GetReorderedColumn (drag_to_index).Rect.X - owner.h_marker;
1840                                 theme.DrawListViewHeaderDragDetails (pe.Graphics, owner, drag_column, target_x);
1841                         }
1842
1843                 }
1844
1845                 public class CheckedIndexCollection : IList, ICollection, IEnumerable
1846                 {
1847                         internal ArrayList list;
1848                         private ListView owner;
1849
1850                         #region Public Constructor
1851                         public CheckedIndexCollection (ListView owner)
1852                         {
1853                                 list = new ArrayList ();
1854                                 this.owner = owner;
1855                         }
1856                         #endregion      // Public Constructor
1857
1858                         #region Public Properties
1859                         [Browsable (false)]
1860                         public int Count {
1861                                 get { return list.Count; }
1862                         }
1863
1864                         public bool IsReadOnly {
1865                                 get { return true; }
1866                         }
1867
1868                         public int this [int index] {
1869                                 get {
1870                                         if (index < 0 || index >= list.Count)
1871                                                 throw new ArgumentOutOfRangeException ("Index out of range.");
1872                                         return (int) list [index];
1873                                 }
1874                         }
1875
1876                         bool ICollection.IsSynchronized {
1877                                 get { return false; }
1878                         }
1879
1880                         object ICollection.SyncRoot {
1881                                 get { return this; }
1882                         }
1883
1884                         bool IList.IsFixedSize {
1885                                 get { return true; }
1886                         }
1887
1888                         object IList.this [int index] {
1889                                 get { return this [index]; }
1890                                 set { throw new NotSupportedException ("SetItem operation is not supported."); }
1891                         }
1892                         #endregion      // Public Properties
1893
1894                         #region Public Methods
1895                         public bool Contains (int checkedIndex)
1896                         {
1897                                 return list.Contains (checkedIndex);
1898                         }
1899
1900                         public IEnumerator GetEnumerator ()
1901                         {
1902                                 return list.GetEnumerator ();
1903                         }
1904
1905                         void ICollection.CopyTo (Array dest, int index)
1906                         {
1907                                 list.CopyTo (dest, index);
1908                         }
1909
1910                         int IList.Add (object value)
1911                         {
1912                                 throw new NotSupportedException ("Add operation is not supported.");
1913                         }
1914
1915                         void IList.Clear ()
1916                         {
1917                                 throw new NotSupportedException ("Clear operation is not supported.");
1918                         }
1919
1920                         bool IList.Contains (object checkedIndex)
1921                         {
1922                                 return list.Contains (checkedIndex);
1923                         }
1924
1925                         int IList.IndexOf (object checkedIndex)
1926                         {
1927                                 return list.IndexOf (checkedIndex);
1928                         }
1929
1930                         void IList.Insert (int index, object value)
1931                         {
1932                                 throw new NotSupportedException ("Insert operation is not supported.");
1933                         }
1934
1935                         void IList.Remove (object value)
1936                         {
1937                                 throw new NotSupportedException ("Remove operation is not supported.");
1938                         }
1939
1940                         void IList.RemoveAt (int index)
1941                         {
1942                                 throw new NotSupportedException ("RemoveAt operation is not supported.");
1943                         }
1944
1945                         public int IndexOf (int checkedIndex)
1946                         {
1947                                 return list.IndexOf (checkedIndex);
1948                         }
1949                         #endregion      // Public Methods
1950
1951                 }       // CheckedIndexCollection
1952
1953                 public class CheckedListViewItemCollection : IList, ICollection, IEnumerable
1954                 {
1955                         internal ArrayList list;
1956                         private ListView owner;
1957
1958                         #region Public Constructor
1959                         public CheckedListViewItemCollection (ListView owner)
1960                         {
1961                                 list = new ArrayList ();
1962                                 this.owner = owner;
1963                         }
1964                         #endregion      // Public Constructor
1965
1966                         #region Public Properties
1967                         [Browsable (false)]
1968                         public int Count {
1969                                 get { return list.Count; }
1970                         }
1971
1972                         public bool IsReadOnly {
1973                                 get { return true; }
1974                         }
1975
1976                         public ListViewItem this [int index] {
1977                                 get {
1978                                         if (index < 0 || index >= list.Count)
1979                                                 throw new ArgumentOutOfRangeException ("Index out of range.");
1980                                         return (ListViewItem) list [index];
1981                                 }
1982                         }
1983
1984                         bool ICollection.IsSynchronized {
1985                                 get { return list.IsSynchronized; }
1986                         }
1987
1988                         object ICollection.SyncRoot {
1989                                 get { return this; }
1990                         }
1991
1992                         bool IList.IsFixedSize {
1993                                 get { return true; }
1994                         }
1995
1996                         object IList.this [int index] {
1997                                 get { return this [index]; }
1998                                 set { throw new NotSupportedException ("SetItem operation is not supported."); }
1999                         }
2000                         #endregion      // Public Properties
2001
2002                         #region Public Methods
2003                         public bool Contains (ListViewItem item)
2004                         {
2005                                 return list.Contains (item);
2006                         }
2007
2008                         public void CopyTo (Array dest, int index)
2009                         {
2010                                 list.CopyTo (dest, index);
2011                         }
2012
2013                         public IEnumerator GetEnumerator ()
2014                         {
2015                                 return list.GetEnumerator ();
2016                         }
2017
2018                         int IList.Add (object value)
2019                         {
2020                                 throw new NotSupportedException ("Add operation is not supported.");
2021                         }
2022
2023                         void IList.Clear ()
2024                         {
2025                                 throw new NotSupportedException ("Clear operation is not supported.");
2026                         }
2027
2028                         bool IList.Contains (object item)
2029                         {
2030                                 return list.Contains (item);
2031                         }
2032
2033                         int IList.IndexOf (object item)
2034                         {
2035                                 return list.IndexOf (item);
2036                         }
2037
2038                         void IList.Insert (int index, object value)
2039                         {
2040                                 throw new NotSupportedException ("Insert operation is not supported.");
2041                         }
2042
2043                         void IList.Remove (object value)
2044                         {
2045                                 throw new NotSupportedException ("Remove operation is not supported.");
2046                         }
2047
2048                         void IList.RemoveAt (int index)
2049                         {
2050                                 throw new NotSupportedException ("RemoveAt operation is not supported.");
2051                         }
2052
2053                         public int IndexOf (ListViewItem item)
2054                         {
2055                                 return list.IndexOf (item);
2056                         }
2057                         #endregion      // Public Methods
2058
2059                 }       // CheckedListViewItemCollection
2060
2061                 public class ColumnHeaderCollection : IList, ICollection, IEnumerable
2062                 {
2063                         internal ArrayList list;
2064                         private ListView owner;
2065
2066                         #region Public Constructor
2067                         public ColumnHeaderCollection (ListView owner)
2068                         {
2069                                 list = new ArrayList ();
2070                                 this.owner = owner;
2071                         }
2072                         #endregion      // Public Constructor
2073
2074                         #region Public Properties
2075                         [Browsable (false)]
2076                         public int Count {
2077                                 get { return list.Count; }
2078                         }
2079
2080                         public bool IsReadOnly {
2081                                 get { return false; }
2082                         }
2083
2084                         public virtual ColumnHeader this [int index] {
2085                                 get {
2086                                         if (index < 0 || index >= list.Count)
2087                                                 throw new ArgumentOutOfRangeException ("Index out of range.");
2088                                         return (ColumnHeader) list [index];
2089                                 }
2090                         }
2091
2092                         bool ICollection.IsSynchronized {
2093                                 get { return true; }
2094                         }
2095
2096                         object ICollection.SyncRoot {
2097                                 get { return this; }
2098                         }
2099
2100                         bool IList.IsFixedSize {
2101                                 get { return list.IsFixedSize; }
2102                         }
2103
2104                         object IList.this [int index] {
2105                                 get { return this [index]; }
2106                                 set { throw new NotSupportedException ("SetItem operation is not supported."); }
2107                         }
2108                         #endregion      // Public Properties
2109
2110                         #region Public Methods
2111                         public virtual int Add (ColumnHeader value)
2112                         {
2113                                 int idx;
2114                                 value.owner = this.owner;
2115                                 idx = list.Add (value);
2116                                 owner.Redraw (true);
2117                                 return idx;
2118                         }
2119
2120                         public virtual ColumnHeader Add (string str, int width, HorizontalAlignment textAlign)
2121                         {
2122                                 ColumnHeader colHeader = new ColumnHeader (this.owner, str, textAlign, width);
2123                                 this.Add (colHeader);
2124                                 return colHeader;
2125                         }
2126
2127                         public virtual void AddRange (ColumnHeader [] values)
2128                         {
2129                                 foreach (ColumnHeader colHeader in values) {
2130                                         colHeader.owner = this.owner;
2131                                         Add (colHeader);
2132                                 }
2133
2134                                 owner.Redraw (true);
2135                         }
2136
2137                         public virtual void Clear ()
2138                         {
2139                                 list.Clear ();
2140                                 owner.Redraw (true);
2141                         }
2142
2143                         public bool Contains (ColumnHeader value)
2144                         {
2145                                 return list.Contains (value);
2146                         }
2147
2148                         public IEnumerator GetEnumerator ()
2149                         {
2150                                 return list.GetEnumerator ();
2151                         }
2152
2153                         void ICollection.CopyTo (Array dest, int index)
2154                         {
2155                                 list.CopyTo (dest, index);
2156                         }
2157
2158                         int IList.Add (object value)
2159                         {
2160                                 if (! (value is ColumnHeader)) {
2161                                         throw new ArgumentException ("Not of type ColumnHeader", "value");
2162                                 }
2163
2164                                 return this.Add ((ColumnHeader) value);
2165                         }
2166
2167                         bool IList.Contains (object value)
2168                         {
2169                                 if (! (value is ColumnHeader)) {
2170                                         throw new ArgumentException ("Not of type ColumnHeader", "value");
2171                                 }
2172
2173                                 return this.Contains ((ColumnHeader) value);
2174                         }
2175
2176                         int IList.IndexOf (object value)
2177                         {
2178                                 if (! (value is ColumnHeader)) {
2179                                         throw new ArgumentException ("Not of type ColumnHeader", "value");
2180                                 }
2181
2182                                 return this.IndexOf ((ColumnHeader) value);
2183                         }
2184
2185                         void IList.Insert (int index, object value)
2186                         {
2187                                 if (! (value is ColumnHeader)) {
2188                                         throw new ArgumentException ("Not of type ColumnHeader", "value");
2189                                 }
2190
2191                                 this.Insert (index, (ColumnHeader) value);
2192                         }
2193
2194                         void IList.Remove (object value)
2195                         {
2196                                 if (! (value is ColumnHeader)) {
2197                                         throw new ArgumentException ("Not of type ColumnHeader", "value");
2198                                 }
2199
2200                                 this.Remove ((ColumnHeader) value);
2201                         }
2202
2203                         public int IndexOf (ColumnHeader value)
2204                         {
2205                                 return list.IndexOf (value);
2206                         }
2207
2208                         public void Insert (int index, ColumnHeader value)
2209                         {
2210                                 // LAMESPEC: MSDOCS say greater than or equal to the value of the Count property
2211                                 // but it's really only greater.
2212                                 if (index < 0 || index > list.Count)
2213                                         throw new ArgumentOutOfRangeException ("Index out of range.");
2214
2215                                 value.owner = this.owner;
2216                                 list.Insert (index, value);
2217                                 owner.Redraw (true);
2218                         }
2219
2220                         public void Insert (int index, string str, int width, HorizontalAlignment textAlign)
2221                         {
2222                                 ColumnHeader colHeader = new ColumnHeader (this.owner, str, textAlign, width);
2223                                 this.Insert (index, colHeader);
2224                         }
2225
2226                         public virtual void Remove (ColumnHeader column)
2227                         {
2228                                 // TODO: Update Column internal index ?
2229                                 list.Remove (column);
2230                                 owner.Redraw (true);
2231                         }
2232
2233                         public virtual void RemoveAt (int index)
2234                         {
2235                                 if (index < 0 || index >= list.Count)
2236                                         throw new ArgumentOutOfRangeException ("Index out of range.");
2237
2238                                 // TODO: Update Column internal index ?
2239                                 list.RemoveAt (index);
2240                                 owner.Redraw (true);
2241                         }
2242                         #endregion      // Public Methods
2243
2244
2245                 }       // ColumnHeaderCollection
2246
2247                 public class ListViewItemCollection : IList, ICollection, IEnumerable
2248                 {
2249                         internal ArrayList list;
2250                         private ListView owner;
2251
2252                         #region Public Constructor
2253                         public ListViewItemCollection (ListView owner)
2254                         {
2255                                 list = new ArrayList ();
2256                                 this.owner = owner;
2257                         }
2258                         #endregion      // Public Constructor
2259
2260                         #region Public Properties
2261                         [Browsable (false)]
2262                         public int Count {
2263                                 get { return list.Count; }
2264                         }
2265
2266                         public bool IsReadOnly {
2267                                 get { return false; }
2268                         }
2269
2270                         public virtual ListViewItem this [int displayIndex] {
2271                                 get {
2272                                         if (displayIndex < 0 || displayIndex >= list.Count)
2273                                                 throw new ArgumentOutOfRangeException ("Index out of range.");
2274                                         return (ListViewItem) list [displayIndex];
2275                                 }
2276
2277                                 set {
2278                                         if (displayIndex < 0 || displayIndex >= list.Count)
2279                                                 throw new ArgumentOutOfRangeException ("Index out of range.");
2280
2281                                         if (list.Contains (value))
2282                                                 throw new ArgumentException ("An item cannot be added more than once. To add an item again, you need to clone it.", "value");
2283
2284                                         value.Owner = owner;
2285                                         list [displayIndex] = value;
2286
2287                                         owner.Redraw (true);
2288                                 }
2289                         }
2290
2291                         bool ICollection.IsSynchronized {
2292                                 get { return true; }
2293                         }
2294
2295                         object ICollection.SyncRoot {
2296                                 get { return this; }
2297                         }
2298
2299                         bool IList.IsFixedSize {
2300                                 get { return list.IsFixedSize; }
2301                         }
2302
2303                         object IList.this [int index] {
2304                                 get { return this [index]; }
2305                                 set {
2306                                         if (value is ListViewItem)
2307                                                 this [index] = (ListViewItem) value;
2308                                         else
2309                                                 this [index] = new ListViewItem (value.ToString ());
2310                                 }
2311                         }
2312                         #endregion      // Public Properties
2313
2314                         #region Public Methods
2315                         public virtual ListViewItem Add (ListViewItem value)
2316                         {
2317                                 if (list.Contains (value))
2318                                         throw new ArgumentException ("An item cannot be added more than once. To add an item again, you need to clone it.", "value");
2319
2320                                 value.Owner = owner;
2321                                 list.Add (value);
2322
2323                                 if (owner.Sorting != SortOrder.None)
2324                                         owner.Sort ();
2325
2326                                 owner.Redraw (true);
2327
2328                                 return value;
2329                         }
2330
2331                         public virtual ListViewItem Add (string text)
2332                         {
2333                                 ListViewItem item = new ListViewItem (text);
2334                                 return this.Add (item);
2335                         }
2336
2337                         public virtual ListViewItem Add (string text, int imageIndex)
2338                         {
2339                                 ListViewItem item = new ListViewItem (text, imageIndex);
2340                                 return this.Add (item);
2341                         }
2342
2343                         public void AddRange (ListViewItem [] values)
2344                         {
2345                                 list.Clear ();
2346                                 owner.SelectedItems.list.Clear ();
2347                                 owner.SelectedIndices.list.Clear ();
2348                                 owner.CheckedItems.list.Clear ();
2349                                 owner.CheckedIndices.list.Clear ();
2350
2351                                 foreach (ListViewItem item in values) {
2352                                         item.Owner = owner;
2353                                         list.Add (item);
2354                                 }
2355
2356                                 if (owner.Sorting != SortOrder.None)
2357                                         owner.Sort ();
2358
2359                                 owner.Redraw (true);
2360                         }
2361
2362                         public virtual void Clear ()
2363                         {
2364                                 owner.SetFocusedItem (null);
2365                                 owner.h_scroll.Value = owner.v_scroll.Value = 0;
2366                                 list.Clear ();
2367                                 owner.SelectedItems.list.Clear ();
2368                                 owner.SelectedIndices.list.Clear ();
2369                                 owner.CheckedItems.list.Clear ();
2370                                 owner.CheckedIndices.list.Clear ();
2371                                 owner.Redraw (true);
2372                         }
2373
2374                         public bool Contains (ListViewItem item)
2375                         {
2376                                 return list.Contains (item);
2377                         }
2378
2379                         public void CopyTo (Array dest, int index)
2380                         {
2381                                 list.CopyTo (dest, index);
2382                         }
2383
2384                         public IEnumerator GetEnumerator ()
2385                         {
2386                                 return list.GetEnumerator ();
2387                         }
2388
2389                         int IList.Add (object item)
2390                         {
2391                                 int result;
2392                                 ListViewItem li;
2393
2394                                 if (item is ListViewItem) {
2395                                         li = (ListViewItem) item;
2396                                         if (list.Contains (li))
2397                                                 throw new ArgumentException ("An item cannot be added more than once. To add an item again, you need to clone it.", "item");
2398                                 }
2399                                 else
2400                                         li = new ListViewItem (item.ToString ());
2401
2402                                 li.Owner = owner;
2403                                 result = list.Add (li);
2404                                 owner.Redraw (true);
2405
2406                                 return result;
2407                         }
2408
2409                         bool IList.Contains (object item)
2410                         {
2411                                 return list.Contains (item);
2412                         }
2413
2414                         int IList.IndexOf (object item)
2415                         {
2416                                 return list.IndexOf (item);
2417                         }
2418
2419                         void IList.Insert (int index, object item)
2420                         {
2421                                 if (item is ListViewItem)
2422                                         this.Insert (index, (ListViewItem) item);
2423                                 else
2424                                         this.Insert (index, item.ToString ());
2425                         }
2426
2427                         void IList.Remove (object item)
2428                         {
2429                                 Remove ((ListViewItem) item);
2430                         }
2431
2432                         public int IndexOf (ListViewItem item)
2433                         {
2434                                 return list.IndexOf (item);
2435                         }
2436
2437                         public ListViewItem Insert (int index, ListViewItem item)
2438                         {
2439                                 // LAMESPEC: MSDOCS say greater than or equal to the value of the Count property
2440                                 // but it's really only greater.
2441                                 if (index < 0 || index > list.Count)
2442                                         throw new ArgumentOutOfRangeException ("Index out of range.");
2443
2444                                 if (list.Contains (item))
2445                                         throw new ArgumentException ("An item cannot be added more than once. To add an item again, you need to clone it.", "item");
2446
2447                                 item.Owner = owner;
2448                                 list.Insert (index, item);
2449                                 owner.Redraw (true);
2450                                 return item;
2451                         }
2452
2453                         public ListViewItem Insert (int index, string text)
2454                         {
2455                                 return this.Insert (index, new ListViewItem (text));
2456                         }
2457
2458                         public ListViewItem Insert (int index, string text, int imageIndex)
2459                         {
2460                                 return this.Insert (index, new ListViewItem (text, imageIndex));
2461                         }
2462
2463                         public virtual void Remove (ListViewItem item)
2464                         {
2465                                 if (!list.Contains (item))
2466                                         return;
2467
2468                                 owner.SelectedItems.list.Remove (item);
2469                                 owner.SelectedIndices.list.Remove (item.Index);
2470                                 owner.CheckedItems.list.Remove (item);
2471                                 owner.CheckedIndices.list.Remove (item.Index);
2472                                 list.Remove (item);
2473                                 owner.Redraw (true);
2474                         }
2475
2476                         public virtual void RemoveAt (int index)
2477                         {
2478                                 if (index < 0 || index >= list.Count)
2479                                         throw new ArgumentOutOfRangeException ("Index out of range.");
2480
2481                                 list.RemoveAt (index);
2482                                 owner.SelectedItems.list.RemoveAt (index);
2483                                 owner.SelectedIndices.list.RemoveAt (index);
2484                                 owner.CheckedItems.list.RemoveAt (index);
2485                                 owner.CheckedIndices.list.RemoveAt (index);
2486                                 owner.Redraw (false);
2487                         }
2488                         #endregion      // Public Methods
2489
2490                 }       // ListViewItemCollection
2491
2492                 public class SelectedIndexCollection : IList, ICollection, IEnumerable
2493                 {
2494                         internal ArrayList list;
2495                         private ListView owner;
2496
2497                         #region Public Constructor
2498                         public SelectedIndexCollection (ListView owner)
2499                         {
2500                                 list = new ArrayList ();
2501                                 this.owner = owner;
2502                         }
2503                         #endregion      // Public Constructor
2504
2505                         #region Public Properties
2506                         [Browsable (false)]
2507                         public int Count {
2508                                 get { return list.Count; }
2509                         }
2510
2511                         public bool IsReadOnly {
2512                                 get { return true; }
2513                         }
2514
2515                         public int this [int index] {
2516                                 get {
2517                                         if (index < 0 || index >= list.Count)
2518                                                 throw new ArgumentOutOfRangeException ("Index out of range.");
2519                                         return (int) list [index];
2520                                 }
2521                         }
2522
2523                         bool ICollection.IsSynchronized {
2524                                 get { return list.IsSynchronized; }
2525                         }
2526
2527                         object ICollection.SyncRoot {
2528                                 get { return this; }
2529                         }
2530
2531                         bool IList.IsFixedSize {
2532                                 get { return true; }
2533                         }
2534
2535                         object IList.this [int index] {
2536                                 get { return this [index]; }
2537                                 set { throw new NotSupportedException ("SetItem operation is not supported."); }
2538                         }
2539                         #endregion      // Public Properties
2540
2541                         #region Public Methods
2542                         public bool Contains (int selectedIndex)
2543                         {
2544                                 return list.Contains (selectedIndex);
2545                         }
2546
2547                         public void CopyTo (Array dest, int index)
2548                         {
2549                                 list.CopyTo (dest, index);
2550                         }
2551
2552                         public IEnumerator GetEnumerator ()
2553                         {
2554                                 return list.GetEnumerator ();
2555                         }
2556
2557                         int IList.Add (object value)
2558                         {
2559                                 throw new NotSupportedException ("Add operation is not supported.");
2560                         }
2561
2562                         void IList.Clear ()
2563                         {
2564                                 throw new NotSupportedException ("Clear operation is not supported.");
2565                         }
2566
2567                         bool IList.Contains (object selectedIndex)
2568                         {
2569                                 return list.Contains (selectedIndex);
2570                         }
2571
2572                         int IList.IndexOf (object selectedIndex)
2573                         {
2574                                 return list.IndexOf (selectedIndex);
2575                         }
2576
2577                         void IList.Insert (int index, object value)
2578                         {
2579                                 throw new NotSupportedException ("Insert operation is not supported.");
2580                         }
2581
2582                         void IList.Remove (object value)
2583                         {
2584                                 throw new NotSupportedException ("Remove operation is not supported.");
2585                         }
2586
2587                         void IList.RemoveAt (int index)
2588                         {
2589                                 throw new NotSupportedException ("RemoveAt operation is not supported.");
2590                         }
2591
2592                         public int IndexOf (int selectedIndex)
2593                         {
2594                                 return list.IndexOf (selectedIndex);
2595                         }
2596                         #endregion      // Public Methods
2597
2598                 }       // SelectedIndexCollection
2599
2600                 public class SelectedListViewItemCollection : IList, ICollection, IEnumerable
2601                 {
2602                         internal ArrayList list;
2603                         private ListView owner;
2604
2605                         #region Public Constructor
2606                         public SelectedListViewItemCollection (ListView owner)
2607                         {
2608                                 list = new ArrayList ();
2609                                 this.owner = owner;
2610                         }
2611                         #endregion      // Public Constructor
2612
2613                         #region Public Properties
2614                         [Browsable (false)]
2615                         public int Count {
2616                                 get { return list.Count; }
2617                         }
2618
2619                         public bool IsReadOnly {
2620                                 get { return true; }
2621                         }
2622
2623                         public ListViewItem this [int index] {
2624                                 get {
2625                                         if (index < 0 || index >= list.Count)
2626                                                 throw new ArgumentOutOfRangeException ("Index out of range.");
2627                                         return (ListViewItem) list [index];
2628                                 }
2629                         }
2630
2631                         bool ICollection.IsSynchronized {
2632                                 get { return list.IsSynchronized; }
2633                         }
2634
2635                         object ICollection.SyncRoot {
2636                                 get { return this; }
2637                         }
2638
2639                         bool IList.IsFixedSize {
2640                                 get { return true; }
2641                         }
2642
2643                         object IList.this [int index] {
2644                                 get { return this [index]; }
2645                                 set { throw new NotSupportedException ("SetItem operation is not supported."); }
2646                         }
2647                         #endregion      // Public Properties
2648
2649                         #region Public Methods
2650                         public void Clear ()
2651                         {
2652                                 ArrayList copy = (ArrayList) list.Clone ();
2653                                 for (int i = 0; i < copy.Count; i++)
2654                                         ((ListViewItem) copy [i]).Selected = false;
2655
2656                                 list.Clear ();
2657                         }
2658
2659                         public bool Contains (ListViewItem item)
2660                         {
2661                                 return list.Contains (item);
2662                         }
2663
2664                         public void CopyTo (Array dest, int index)
2665                         {
2666                                 list.CopyTo (dest, index);
2667                         }
2668
2669                         public IEnumerator GetEnumerator ()
2670                         {
2671                                 return list.GetEnumerator ();
2672                         }
2673
2674                         int IList.Add (object value)
2675                         {
2676                                 throw new NotSupportedException ("Add operation is not supported.");
2677                         }
2678
2679                         bool IList.Contains (object item)
2680                         {
2681                                 return list.Contains (item);
2682                         }
2683
2684                         int IList.IndexOf (object item)
2685                         {
2686                                 return list.IndexOf (item);
2687                         }
2688
2689                         void IList.Insert (int index, object value)
2690                         {
2691                                 throw new NotSupportedException ("Insert operation is not supported.");
2692                         }
2693
2694                         void IList.Remove (object value)
2695                         {
2696                                 throw new NotSupportedException ("Remove operation is not supported.");
2697                         }
2698
2699                         void IList.RemoveAt (int index)
2700                         {
2701                                 throw new NotSupportedException ("RemoveAt operation is not supported.");
2702                         }
2703
2704                         public int IndexOf (ListViewItem item)
2705                         {
2706                                 return list.IndexOf (item);
2707                         }
2708                         #endregion      // Public Methods
2709
2710                 }       // SelectedListViewItemCollection
2711
2712                 #endregion // Subclasses
2713         }
2714 }