mcs/class/Managed.Windows.Forms/System.Windows.Forms/DataGridView.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) 2005 Novell, Inc. (http://www.novell.com)
  21 //
  22 // Author:
  23 //      Pedro Martínez Juliá <pedromj@gmail.com>
  24 //      Ivan N. Zlatev <contact@i-nz.net>
  25 //
  26
  27 using System;
  28 using System.ComponentModel;
  29 using System.Runtime.InteropServices;
  30 using System.Drawing;
  31 using System.Reflection;
  32 using System.Collections;
  33 using System.Text;
  34 using System.Collections.Generic;
  35
  36 namespace System.Windows.Forms {
  37
  38         [ComVisibleAttribute(true)]
  39         [ClassInterfaceAttribute(ClassInterfaceType.AutoDispatch)]
  40         [Designer("System.Windows.Forms.Design.DataGridViewDesigner, " + Consts.AssemblySystem_Design, "System.ComponentModel.Design.IDesigner")]
  41         [Editor("System.Windows.Forms.Design.DataGridViewComponentEditor, " + Consts.AssemblySystem_Design, typeof (System.ComponentModel.ComponentEditor))]
  42         [ComplexBindingProperties ("DataSource", "DataMember")]
  43         [DefaultEvent ("CellContentClick")]
  44         [Docking (DockingBehavior.Ask)]
  45         public class DataGridView : Control, ISupportInitialize, IBindableComponent, IDropTarget
  46         {
  47
  48                 private DataGridViewAdvancedBorderStyle adjustedTopLeftHeaderBorderStyle;
  49                 private DataGridViewAdvancedBorderStyle advancedCellBorderStyle;
  50                 private DataGridViewAdvancedBorderStyle advancedColumnHeadersBorderStyle;
  51                 private DataGridViewAdvancedBorderStyle advancedRowHeadersBorderStyle;
  52                 private bool allowUserToAddRows;
  53                 private bool allowUserToDeleteRows;
  54                 private bool allowUserToOrderColumns;
  55                 private bool allowUserToResizeColumns;
  56                 private bool allowUserToResizeRows;
  57                 private DataGridViewCellStyle alternatingRowsDefaultCellStyle;
  58                 private Point anchor_cell;
  59                 private bool autoGenerateColumns;
  60                 private bool autoSize;
  61                 private DataGridViewAutoSizeColumnsMode autoSizeColumnsMode;
  62                 private DataGridViewAutoSizeRowsMode autoSizeRowsMode;
  63                 private Color backColor;
  64                 private Color backgroundColor;
  65                 private Image backgroundImage;
  66                 private BorderStyle borderStyle;
  67                 private DataGridViewCellBorderStyle cellBorderStyle;
  68                 private DataGridViewClipboardCopyMode clipboardCopyMode;
  69                 private DataGridViewHeaderBorderStyle columnHeadersBorderStyle;
  70                 private DataGridViewCellStyle columnHeadersDefaultCellStyle;
  71                 private int columnHeadersHeight;
  72                 private DataGridViewColumnHeadersHeightSizeMode columnHeadersHeightSizeMode;
  73                 private bool columnHeadersVisible;
  74                 private DataGridViewColumnCollection columns;
  75                 private DataGridViewCell currentCell;
  76                 private Point currentCellAddress;
  77                 //private DataGridViewRow currentRow;
  78                 private string dataMember;
  79                 private object dataSource;
  80                 private DataGridViewCellStyle defaultCellStyle;
  81                 //private Control editingControl;
  82                 private DataGridViewEditMode editMode;
  83                 private bool enableHeadersVisualStyles = true;
  84                 private DataGridViewCell firstDisplayedCell;
  85                 private int firstDisplayedScrollingColumnHiddenWidth;
  86                 private int firstDisplayedScrollingColumnIndex;
  87                 private int firstDisplayedScrollingRowIndex;
  88                 private Color gridColor = Color.FromKnownColor(KnownColor.ControlDark);
  89                 private int horizontalScrollingOffset;
  90                 private DataGridViewCell hover_cell = null;
  91                 private bool isCurrentCellDirty;
  92                 //private bool isCurrentRowDirty;
  93                 private bool multiSelect;
  94                 private bool readOnly;
  95                 private DataGridViewHeaderBorderStyle rowHeadersBorderStyle;
  96                 private DataGridViewCellStyle rowHeadersDefaultCellStyle;
  97                 private bool rowHeadersVisible;
  98                 private int rowHeadersWidth;
  99                 private DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode;
 100                 private DataGridViewRowCollection rows;
 101                 private DataGridViewCellStyle rowsDefaultCellStyle;
 102                 private DataGridViewRow rowTemplate;
 103                 private ScrollBars scrollBars;
 104                 private DataGridViewSelectionMode selectionMode;
 105                 private bool showCellErrors;
 106                 private bool showCellToolTips;
 107                 private bool showEditingIcon;
 108                 private bool showRowErrors;
 109                 private DataGridViewColumn sortedColumn = null;
 110                 private SortOrder sortOrder;
 111                 private bool standardTab;
 112                 private DataGridViewHeaderCell topLeftHeaderCell;
 113                 private Cursor userSetCursor;
 114                 private int verticalScrollingOffset;
 115                 private bool virtualMode;
 116                 private HScrollBar horizontalScrollBar;
 117                 private VScrollBar verticalScrollBar;
 118                 private Control editingControl;
 119                 private bool is_autogenerating_columns = false;
 120                 private bool is_binding = false;
 121                 private bool new_row_editing = false;
 122
 123                 // These are used to implement selection behaviour with SHIFT pressed.
 124                 private int selected_row = -1;
 125                 private int selected_column = -1;
 126
 127                 // Stuff for error Tooltips
 128                 private Timer tooltip_timer;
 129                 private ToolTip tooltip_window;
 130                 private DataGridViewCell tooltip_currently_showing;
 131
 132                 private DataGridViewSelectedRowCollection selected_rows;
 133                 private DataGridViewSelectedColumnCollection selected_columns;
 134                 private DataGridViewRow editing_row;
 135
 136                 DataGridViewHeaderCell pressed_header_cell;
 137                 DataGridViewHeaderCell entered_header_cell;
 138
 139                 // For column/row resizing via mouse
 140                 private bool column_resize_active = false;
 141                 private bool row_resize_active = false;
 142                 private int resize_band = -1;
 143                 private int resize_band_start = 0;
 144                 private int resize_band_delta = 0;
 145
 146                 public DataGridView ()
 147                 {
 148                         SetStyle (ControlStyles.Opaque, true);
 149                         //SetStyle (ControlStyles.UserMouse, true);
 150                         SetStyle (ControlStyles.OptimizedDoubleBuffer, true);
 151
 152                         adjustedTopLeftHeaderBorderStyle = new DataGridViewAdvancedBorderStyle();
 153                         adjustedTopLeftHeaderBorderStyle.All = DataGridViewAdvancedCellBorderStyle.Single;
 154                         advancedCellBorderStyle = new DataGridViewAdvancedBorderStyle();
 155                         advancedCellBorderStyle.All = DataGridViewAdvancedCellBorderStyle.Single;
 156                         advancedColumnHeadersBorderStyle = new DataGridViewAdvancedBorderStyle();
 157                         advancedColumnHeadersBorderStyle.All = DataGridViewAdvancedCellBorderStyle.Single;
 158                         advancedRowHeadersBorderStyle = new DataGridViewAdvancedBorderStyle();
 159                         advancedRowHeadersBorderStyle.All = DataGridViewAdvancedCellBorderStyle.Single;
 160                         alternatingRowsDefaultCellStyle = new DataGridViewCellStyle();
 161                         allowUserToAddRows = true;
 162                         allowUserToDeleteRows = true;
 163                         allowUserToOrderColumns = false;
 164                         allowUserToResizeColumns = true;
 165                         allowUserToResizeRows = true;
 166                         autoGenerateColumns = true;
 167                         autoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.None;
 168                         autoSizeRowsMode = DataGridViewAutoSizeRowsMode.None;
 169                         backColor = Control.DefaultBackColor;
 170                         backgroundColor = SystemColors.AppWorkspace;
 171                         borderStyle = BorderStyle.FixedSingle;
 172                         cellBorderStyle = DataGridViewCellBorderStyle.Single;
 173                         clipboardCopyMode = DataGridViewClipboardCopyMode.EnableWithAutoHeaderText;
 174                         columnHeadersBorderStyle = DataGridViewHeaderBorderStyle.Single;
 175                         columnHeadersDefaultCellStyle = new DataGridViewCellStyle();
 176                         columnHeadersDefaultCellStyle.BackColor = SystemColors.Control;
 177                         columnHeadersDefaultCellStyle.ForeColor = SystemColors.WindowText;
 178                         columnHeadersDefaultCellStyle.SelectionBackColor = SystemColors.Highlight;
 179                         columnHeadersDefaultCellStyle.SelectionForeColor = SystemColors.HighlightText;
 180                         columnHeadersDefaultCellStyle.Font = this.Font;
 181                         columnHeadersDefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleLeft;
 182                         columnHeadersDefaultCellStyle.WrapMode = DataGridViewTriState.True;
 183                         columnHeadersHeight = 23;
 184                         columnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.EnableResizing;
 185                         columnHeadersVisible = true;
 186                         columns = CreateColumnsInstance();
 187                         columns.CollectionChanged += OnColumnCollectionChanged;
 188                         currentCellAddress = new Point (-1, -1);
 189                         dataMember = String.Empty;
 190                         defaultCellStyle = new DataGridViewCellStyle();
 191                         defaultCellStyle.BackColor = SystemColors.Window;
 192                         defaultCellStyle.ForeColor = SystemColors.ControlText;
 193                         defaultCellStyle.SelectionBackColor = SystemColors.Highlight;
 194                         defaultCellStyle.SelectionForeColor = SystemColors.HighlightText;
 195                         defaultCellStyle.Font = this.Font;
 196                         defaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleLeft;
 197                         defaultCellStyle.WrapMode = DataGridViewTriState.False;
 198                         editMode = DataGridViewEditMode.EditOnKeystrokeOrF2;
 199                         firstDisplayedScrollingColumnHiddenWidth = 0;
 200                         isCurrentCellDirty = false;
 201                         multiSelect = true;
 202                         readOnly = false;
 203                         rowHeadersBorderStyle = DataGridViewHeaderBorderStyle.Single;
 204                         rowHeadersDefaultCellStyle = (DataGridViewCellStyle) columnHeadersDefaultCellStyle.Clone ();
 205                         rowHeadersVisible = true;
 206                         rowHeadersWidth = 41;
 207                         rowHeadersWidthSizeMode = DataGridViewRowHeadersWidthSizeMode.EnableResizing;
 208                         rows = CreateRowsInstance();
 209                         rowsDefaultCellStyle = new DataGridViewCellStyle();
 210                         selectionMode = DataGridViewSelectionMode.RowHeaderSelect;
 211                         showCellErrors = true;
 212                         showEditingIcon = true;
 213                         scrollBars = ScrollBars.Both;
 214                         userSetCursor = Cursor.Current;
 215                         virtualMode = false;
 216
 217                         horizontalScrollBar = new HScrollBar();
 218                         horizontalScrollBar.Scroll += OnHScrollBarScroll;
 219                         horizontalScrollBar.Visible = false;
 220
 221                         verticalScrollBar = new VScrollBar();
 222                         verticalScrollBar.Scroll += OnVScrollBarScroll;
 223                         verticalScrollBar.Visible = false;
 224
 225                         Controls.AddRange (new Control[] {horizontalScrollBar, verticalScrollBar});
 226                 }
 227
 228                 void ISupportInitialize.BeginInit ()
 229                 {
 230                 }
 231
 232                 void ISupportInitialize.EndInit ()
 233                 {
 234                 }
 235
 236                 // Propiedades
 237
 238                 [Browsable (false)]
 239                 [EditorBrowsable (EditorBrowsableState.Advanced)]
 240                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 241                 public virtual DataGridViewAdvancedBorderStyle AdjustedTopLeftHeaderBorderStyle {
 242                         get { return adjustedTopLeftHeaderBorderStyle; }
 243                 }
 244
 245                 [Browsable (false)]
 246                 [EditorBrowsable (EditorBrowsableState.Advanced)]
 247                 public DataGridViewAdvancedBorderStyle AdvancedCellBorderStyle {
 248                         get { return advancedCellBorderStyle; }
 249                 }
 250
 251                 [Browsable (false)]
 252                 [EditorBrowsable (EditorBrowsableState.Advanced)]
 253                 public DataGridViewAdvancedBorderStyle AdvancedColumnHeadersBorderStyle {
 254                         get { return advancedColumnHeadersBorderStyle; }
 255                 }
 256
 257                 [Browsable (false)]
 258                 [EditorBrowsable (EditorBrowsableState.Advanced)]
 259                 public DataGridViewAdvancedBorderStyle AdvancedRowHeadersBorderStyle {
 260                         get { return advancedRowHeadersBorderStyle; }
 261                 }
 262
 263                 [DefaultValue (true)]
 264                 public bool AllowUserToAddRows {
 265                         get {
 266                                 if (allowUserToAddRows && DataManager != null)
 267                                         return DataManager.AllowNew;
 268                                 return allowUserToAddRows;
 269                         }
 270                         set {
 271                                 if (allowUserToAddRows != value) {
 272                                         allowUserToAddRows = value;
 273                                         if (!value) {
 274                                                 if (new_row_editing)
 275                                                         CancelEdit ();
 276                                                 RemoveEditingRow ();
 277                                         } else {
 278                                                 PrepareEditingRow (false, false);
 279                                         }
 280                                         OnAllowUserToAddRowsChanged(EventArgs.Empty);
 281                                         Invalidate ();
 282                                 }
 283                         }
 284                 }
 285
 286                 [DefaultValue (true)]
 287                 public bool AllowUserToDeleteRows {
 288                         get {
 289                                 if (allowUserToDeleteRows && DataManager != null)
 290                                         return DataManager.AllowRemove;
 291                                 return allowUserToDeleteRows;
 292                         }
 293                         set {
 294                                 if (allowUserToDeleteRows != value) {
 295                                         allowUserToDeleteRows = value;
 296                                         OnAllowUserToDeleteRowsChanged(EventArgs.Empty);
 297                                 }
 298                         }
 299                 }
 300
 301                 [DefaultValue (false)]
 302                 public bool AllowUserToOrderColumns {
 303                         get { return allowUserToOrderColumns; }
 304                         set {
 305                                 if (allowUserToOrderColumns != value) {
 306                                         allowUserToOrderColumns = value;
 307                                         OnAllowUserToOrderColumnsChanged(EventArgs.Empty);
 308                                 }
 309                         }
 310                 }
 311
 312                 [DefaultValue (true)]
 313                 public bool AllowUserToResizeColumns {
 314                         get { return allowUserToResizeColumns; }
 315                         set {
 316                                 if (allowUserToResizeColumns != value) {
 317                                         allowUserToResizeColumns = value;
 318                                         OnAllowUserToResizeColumnsChanged(EventArgs.Empty);
 319                                 }
 320                         }
 321                 }
 322
 323                 [DefaultValue (true)]
 324                 public bool AllowUserToResizeRows {
 325                         get { return allowUserToResizeRows; }
 326                         set {
 327                                 if (allowUserToResizeRows != value) {
 328                                         allowUserToResizeRows = value;
 329                                         OnAllowUserToResizeRowsChanged(EventArgs.Empty);
 330                                 }
 331                         }
 332                 }
 333
 334                 public DataGridViewCellStyle AlternatingRowsDefaultCellStyle {
 335                         get { return alternatingRowsDefaultCellStyle; }
 336                         set {
 337                                 if (alternatingRowsDefaultCellStyle != value) {
 338                                         alternatingRowsDefaultCellStyle = value;
 339                                         OnAlternatingRowsDefaultCellStyleChanged(EventArgs.Empty);
 340                                         Invalidate();
 341                                 }
 342                         }
 343                 }
 344
 345                 [Browsable (false)]
 346                 [EditorBrowsable (EditorBrowsableState.Advanced)]
 347                 [DefaultValue (true)]
 348                 public bool AutoGenerateColumns {
 349                         get { return autoGenerateColumns; }
 350                         set {
 351                                 if (autoGenerateColumns != value) {
 352                                         autoGenerateColumns = value;
 353                                         OnAutoGenerateColumnsChanged(EventArgs.Empty);
 354                                 }
 355                         }
 356                 }
 357
 358                 public override bool AutoSize {
 359                         get { return autoSize; }
 360                         set {
 361                                 if (autoSize != value) {
 362                                         autoSize = value;
 363                                         //OnAutoSizeChanged(EventArgs.Empty);
 364                                 }
 365                         }
 366                 }
 367
 368                 [DefaultValue (DataGridViewAutoSizeColumnsMode.None)]
 369                 public DataGridViewAutoSizeColumnsMode AutoSizeColumnsMode {
 370                         get { return autoSizeColumnsMode; }
 371                         set {
 372                                 if (!Enum.IsDefined(typeof(DataGridViewAutoSizeColumnsMode), value)) {
 373                                         throw new InvalidEnumArgumentException("Value is not valid DataGridViewAutoSizeColumnsMode.");
 374                                 }
 375                                 if (value == DataGridViewAutoSizeColumnsMode.ColumnHeader && columnHeadersVisible == false) {
 376                                         foreach (DataGridViewColumn col in columns) {
 377                                                 if (col.AutoSizeMode == DataGridViewAutoSizeColumnMode.NotSet) {
 378                                                                 throw new InvalidOperationException("Cant set this property to ColumnHeader in this DataGridView.");
 379                                                 }
 380                                         }
 381                                 }
 382                                 if (value == DataGridViewAutoSizeColumnsMode.Fill) {
 383                                         foreach (DataGridViewColumn col in columns) {
 384                                                 if (col.AutoSizeMode == DataGridViewAutoSizeColumnMode.NotSet) {
 385                                                         if (col.Frozen) {
 386                                                                 throw new InvalidOperationException("Cant set this property to Fill in this DataGridView.");
 387                                                         }
 388                                                 }
 389                                         }
 390                                 }
 391
 392                                 autoSizeColumnsMode = value;
 393                                 AutoResizeColumns (value);
 394                                 Invalidate ();
 395                         }
 396                 }
 397
 398                 [DefaultValue (DataGridViewAutoSizeRowsMode.None)]
 399                 public DataGridViewAutoSizeRowsMode AutoSizeRowsMode {
 400                         get { return autoSizeRowsMode; }
 401                         set {
 402                                 if (autoSizeRowsMode != value) {
 403                                         if (!Enum.IsDefined(typeof(DataGridViewAutoSizeRowsMode), value)) {
 404                                                 throw new InvalidEnumArgumentException("Value is not valid DataGridViewRowsMode.");
 405                                         }
 406                                         if ((value == DataGridViewAutoSizeRowsMode.AllHeaders || value == DataGridViewAutoSizeRowsMode.DisplayedHeaders) && rowHeadersVisible == false) {
 407                                                 throw new InvalidOperationException("Cant set this property to AllHeaders or DisplayedHeaders in this DataGridView.");
 408                                         }
 409                                         autoSizeRowsMode = value;
 410
 411                                         if (value == DataGridViewAutoSizeRowsMode.None)
 412                                                 foreach (DataGridViewRow row in Rows)
 413                                                         row.ResetToExplicitHeight ();
 414                                         else
 415                                                 AutoResizeRows (value);
 416
 417                                         OnAutoSizeRowsModeChanged(new DataGridViewAutoSizeModeEventArgs(false));
 418                                         Invalidate ();
 419                                         ////////////////////////////////////////////////////////////////
 420                                 }
 421                         }
 422                 }
 423
 424                 [Browsable (false)]
 425                 [EditorBrowsable (EditorBrowsableState.Never)]
 426                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 427                 public override Color BackColor {
 428                         get { return backColor; }
 429                         set {
 430                                 if (backColor != value) {
 431                                         backColor = value;
 432                                         OnBackColorChanged(EventArgs.Empty);
 433                                 }
 434                         }
 435                 }
 436
 437                 public Color BackgroundColor {
 438                         get { return backgroundColor; }
 439                         set {
 440                                 if (backgroundColor != value) {
 441                                         if (value == Color.Empty) {
 442                                                 throw new ArgumentException("Cant set an Empty color.");
 443                                         }
 444                                         backgroundColor = value;
 445                                         OnBackgroundColorChanged(EventArgs.Empty);
 446                                 }
 447                         }
 448                 }
 449
 450                 [Browsable (false)]
 451                 [EditorBrowsable (EditorBrowsableState.Never)]
 452                 public override Image BackgroundImage {
 453                         get { return backgroundImage; }
 454                         set {
 455                                 if (backgroundImage != value) {
 456                                         backgroundImage = value;
 457                                         OnBackgroundImageChanged(EventArgs.Empty);
 458                                 }
 459                         }
 460                 }
 461
 462                 [Browsable (false)]
 463                 [EditorBrowsable (EditorBrowsableState.Never)]
 464                 public override ImageLayout BackgroundImageLayout {
 465                         get { return base.BackgroundImageLayout; }
 466                         set { base.BackgroundImageLayout = value; }
 467                 }
 468
 469                 [DefaultValue (BorderStyle.FixedSingle)]
 470                 public BorderStyle BorderStyle {
 471                         get { return borderStyle; }
 472                         set {
 473                                 if (borderStyle != value) {
 474                                         if (!Enum.IsDefined(typeof(BorderStyle), value)) {
 475                                                 throw new InvalidEnumArgumentException("Invalid border style.");
 476                                         }
 477                                         borderStyle = value;
 478                                         OnBorderStyleChanged(EventArgs.Empty);
 479                                 }
 480                         }
 481                 }
 482
 483                 internal int BorderWidth {
 484                         get {
 485                                 switch (BorderStyle) {
 486                                 case BorderStyle.Fixed3D:
 487                                         return 2;
 488                                 case BorderStyle.FixedSingle:
 489                                         return 1;
 490                                 case BorderStyle.None:
 491                                 default:
 492                                         return 0;
 493                                 }
 494                         }
 495                 }
 496
 497                 [Browsable (true)]
 498                 [DefaultValue (DataGridViewCellBorderStyle.Single)]
 499                 public DataGridViewCellBorderStyle CellBorderStyle {
 500                         get { return cellBorderStyle; }
 501                         set {
 502                                 if (cellBorderStyle != value) {
 503                                         if (value == DataGridViewCellBorderStyle.Custom)
 504                                                 throw new ArgumentException ("CellBorderStyle cannot be set to Custom.");
 505
 506                                         cellBorderStyle = value;
 507
 508                                         DataGridViewAdvancedBorderStyle border = new DataGridViewAdvancedBorderStyle ();
 509
 510                                         switch (cellBorderStyle) {
 511                                                 case DataGridViewCellBorderStyle.Single:
 512                                                         border.All = DataGridViewAdvancedCellBorderStyle.Single;
 513                                                         break;
 514                                                 case DataGridViewCellBorderStyle.Raised:
 515                                                 case DataGridViewCellBorderStyle.RaisedVertical:
 516                                                         border.Bottom = DataGridViewAdvancedCellBorderStyle.None;
 517                                                         border.Top = DataGridViewAdvancedCellBorderStyle.None;
 518                                                         border.Left = DataGridViewAdvancedCellBorderStyle.Outset;
 519                                                         border.Right = DataGridViewAdvancedCellBorderStyle.Outset;
 520                                                         break;
 521                                                 case DataGridViewCellBorderStyle.Sunken:
 522                                                         border.All = DataGridViewAdvancedCellBorderStyle.Inset;
 523                                                         break;
 524                                                 case DataGridViewCellBorderStyle.None:
 525                                                         border.All = DataGridViewAdvancedCellBorderStyle.None;
 526                                                         break;
 527                                                 case DataGridViewCellBorderStyle.SingleVertical:
 528                                                         border.Bottom = DataGridViewAdvancedCellBorderStyle.None;
 529                                                         border.Top = DataGridViewAdvancedCellBorderStyle.None;
 530                                                         border.Left = DataGridViewAdvancedCellBorderStyle.None;
 531                                                         border.Right = DataGridViewAdvancedCellBorderStyle.Single;
 532                                                         break;
 533                                                 case DataGridViewCellBorderStyle.SunkenVertical:
 534                                                         border.Bottom = DataGridViewAdvancedCellBorderStyle.None;
 535                                                         border.Top = DataGridViewAdvancedCellBorderStyle.None;
 536                                                         border.Left = DataGridViewAdvancedCellBorderStyle.Inset;
 537                                                         border.Right = DataGridViewAdvancedCellBorderStyle.Inset;
 538                                                         break;
 539                                                 case DataGridViewCellBorderStyle.SingleHorizontal:
 540                                                 case DataGridViewCellBorderStyle.SunkenHorizontal:
 541                                                         border.Bottom = DataGridViewAdvancedCellBorderStyle.Inset;
 542                                                         border.Top = DataGridViewAdvancedCellBorderStyle.Inset;
 543                                                         border.Left = DataGridViewAdvancedCellBorderStyle.None;
 544                                                         border.Right = DataGridViewAdvancedCellBorderStyle.None;
 545                                                         break;
 546                                                 case DataGridViewCellBorderStyle.RaisedHorizontal:
 547                                                         border.Bottom = DataGridViewAdvancedCellBorderStyle.Outset;
 548                                                         border.Top = DataGridViewAdvancedCellBorderStyle.Outset;
 549                                                         border.Left = DataGridViewAdvancedCellBorderStyle.None;
 550                                                         border.Right = DataGridViewAdvancedCellBorderStyle.None;
 551                                                         break;
 552                                         }
 553
 554                                         advancedCellBorderStyle = border;
 555
 556                                         OnCellBorderStyleChanged (EventArgs.Empty);
 557                                 }
 558                         }
 559                 }
 560
 561                 [Browsable (true)]
 562                 [DefaultValue (DataGridViewClipboardCopyMode.EnableWithAutoHeaderText)]
 563                 public DataGridViewClipboardCopyMode ClipboardCopyMode {
 564                         get { return clipboardCopyMode; }
 565                         set { clipboardCopyMode = value; }
 566                 }
 567
 568                 [Browsable (false)]
 569                 [EditorBrowsable (EditorBrowsableState.Advanced)]
 570                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 571                 [DefaultValue (0)]
 572                 public int ColumnCount {
 573                         get { return columns.Count; }
 574                         set {
 575                                 if (value < 0) {
 576                                         throw new ArgumentOutOfRangeException("ColumnCount",
 577                                                 "ColumnCount must be >= 0.");
 578                                 }
 579                                 if (dataSource != null) {
 580                                         throw new InvalidOperationException("Cant change column count if DataSource is set.");
 581                                 }
 582                                 if (value < columns.Count) {
 583                                         for (int i = columns.Count -1; i >= value; i--) {
 584                                                 columns.RemoveAt(i);
 585                                         }
 586                                 }
 587                                 else if (value > columns.Count) {
 588                                         for (int i = columns.Count; i < value; i++) {
 589                                                 DataGridViewTextBoxColumn col = new DataGridViewTextBoxColumn ();
 590                                                 columns.Add(col);
 591                                         }
 592                                 }
 593                         }
 594                 }
 595
 596                 [Browsable (true)]
 597                 [DefaultValue (DataGridViewHeaderBorderStyle.Raised)]
 598                 public DataGridViewHeaderBorderStyle ColumnHeadersBorderStyle {
 599                         get { return columnHeadersBorderStyle; }
 600                         set {
 601                                 if (columnHeadersBorderStyle != value) {
 602                                         columnHeadersBorderStyle = value;
 603                                         OnColumnHeadersBorderStyleChanged(EventArgs.Empty);
 604                                 }
 605                         }
 606                 }
 607
 608                 [AmbientValue (null)]
 609                 public DataGridViewCellStyle ColumnHeadersDefaultCellStyle {
 610                         get { return columnHeadersDefaultCellStyle; }
 611                         set {
 612                                 if (columnHeadersDefaultCellStyle != value) {
 613                                         columnHeadersDefaultCellStyle = value;
 614                                         OnColumnHeadersDefaultCellStyleChanged(EventArgs.Empty);
 615                                 }
 616                         }
 617                 }
 618
 619                 [Localizable (true)]
 620                 public int ColumnHeadersHeight {
 621                         get { return columnHeadersHeight; }
 622                         set {
 623                                 if (columnHeadersHeight != value) {
 624                                         if (value < 4) {
 625                                                 throw new ArgumentOutOfRangeException("ColumnHeadersHeight",
 626                                                         "Column headers height cant be less than 4.");
 627                                         }
 628                                         if (value > 32768 ) {
 629                                                 throw new ArgumentOutOfRangeException("ColumnHeadersHeight",
 630                                                         "Column headers height cannot be more than 32768.");
 631                                         }
 632                                         columnHeadersHeight = value;
 633                                         OnColumnHeadersHeightChanged(EventArgs.Empty);
 634
 635                                         if (columnHeadersVisible)
 636                                                 Invalidate ();
 637                                 }
 638                         }
 639                 }
 640
 641                 [RefreshProperties (RefreshProperties.All)]
 642                 [DefaultValue (DataGridViewColumnHeadersHeightSizeMode.EnableResizing)]
 643                 public DataGridViewColumnHeadersHeightSizeMode ColumnHeadersHeightSizeMode {
 644                         get { return columnHeadersHeightSizeMode; }
 645                         set {
 646                                 if (columnHeadersHeightSizeMode != value) {
 647                                         if (!Enum.IsDefined(typeof(DataGridViewColumnHeadersHeightSizeMode), value)) {
 648                                                 throw new InvalidEnumArgumentException("Value is not a valid DataGridViewColumnHeadersHeightSizeMode.");
 649                                         }
 650                                         columnHeadersHeightSizeMode = value;
 651                                         OnColumnHeadersHeightSizeModeChanged(new DataGridViewAutoSizeModeEventArgs(false));
 652                                 }
 653                         }
 654                 }
 655
 656                 [DefaultValue (true)]
 657                 public bool ColumnHeadersVisible {
 658                         get { return columnHeadersVisible; }
 659                         set {
 660                                 if (columnHeadersVisible != value) {
 661                                         columnHeadersVisible = value;
 662                                         Invalidate ();
 663                                 }
 664                         }
 665                 }
 666
 667                 [MergableProperty (false)]
 668                 [Editor ("System.Windows.Forms.Design.DataGridViewColumnCollectionEditor, " + Consts.AssemblySystem_Design, typeof (System.Drawing.Design.UITypeEditor))]
 669                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]
 670                 public DataGridViewColumnCollection Columns {
 671                         get { return columns; }
 672                 }
 673
 674                 [Browsable (false)]
 675                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 676                 public DataGridViewCell CurrentCell {
 677                         get { return currentCell; }
 678                         set {
 679                                 /////////////////////////////////////////////////////
 680                                 /// *** InvalidOperationException ***
 681                                 /// Changes to the specified cell cannot be committed
 682                                 /// to the data cache, or the new cell is in a hidden
 683                                 /// row.
 684                                 /////////////////////////////////////////////////////
 685                                 if (value == null)
 686                                         MoveCurrentCell (-1, -1, true, false, false, true);
 687                                 else if (value.DataGridView != this)
 688                                         throw new ArgumentException("The cell is not in this DataGridView.");
 689                                 else
 690                                         MoveCurrentCell (value.OwningColumn.Index, value.OwningRow.Index, true, false, false, true);
 691                         }
 692                 }
 693
 694                 [Browsable (false)]
 695                 public Point CurrentCellAddress {
 696                         get { return currentCellAddress; }
 697                 }
 698
 699                 [Browsable (false)]
 700                 public DataGridViewRow CurrentRow {
 701                         get {
 702                                 if (currentCell != null)
 703                                         return currentCell.OwningRow;
 704                                 return null;
 705                         }
 706                 }
 707
 708                 [DefaultValue ("")]
 709                 [Editor ("System.Windows.Forms.Design.DataMemberListEditor, " + Consts.AssemblySystem_Design, typeof (System.Drawing.Design.UITypeEditor))]
 710                 public string DataMember {
 711                         get { return dataMember; }
 712                         set {
 713                                 if (dataMember != value) {
 714                                         dataMember = value;
 715                                         if (BindingContext != null)
 716                                                 ReBind ();
 717                                         OnDataMemberChanged(EventArgs.Empty);
 718                                 }
 719                         }
 720                 }
 721
 722                 [RefreshProperties (RefreshProperties.Repaint)]
 723                 [DefaultValue (null)]
 724                 [AttributeProvider (typeof (IListSource))]
 725                 public object DataSource {
 726                         get { return dataSource; }
 727                         set {
 728                                 /* The System.Windows.Forms.DataGridView class supports the standard Windows Forms data-binding model. This means the data source can be of any type that implements:
 729                                  - the System.Collections.IList interface, including one-dimensional arrays.
 730                                  - the System.ComponentModel.IListSource interface, such as the System.Data.DataTable and System.Data.DataSet classes.
 731                                  - the System.ComponentModel.IBindingList interface, such as the System.ComponentModel.Collections.BindingList<> class.
 732                                  - the System.ComponentModel.IBindingListView interface, such as the System.Windows.Forms.BindingSource class.
 733                                 */
 734                                 if (!(value == null || value is IList || value is IListSource || value is IBindingList || value is IBindingListView))
 735                                         throw new NotSupportedException ("Type cannot be bound.");
 736
 737                                 if (value != DataSource) {
 738                                         if (IsHandleCreated && value != null && BindingContext != null && BindingContext[value] != null)
 739                                                 DataMember = String.Empty;
 740                                         ClearBinding ();
 741
 742
 743                                         // Do not set dataSource prior to the BindingContext check because there is some lazy initialization
 744                                         // code which might result in double call to ReBind here and in OnBindingContextChanged
 745                                         if (BindingContext != null) {
 746                                                 dataSource = value;
 747                                                 ReBind ();
 748                                         } else {
 749                                                 dataSource = value;
 750                                         }
 751
 752                                         OnDataSourceChanged (EventArgs.Empty);
 753                                 }
 754                         }
 755                 }
 756
 757                 internal CurrencyManager DataManager {
 758                         get {
 759                                 if (DataSource != null && BindingContext != null) {
 760                                         string dataMember = DataMember;
 761                                         if (dataMember == null)
 762                                                 dataMember = String.Empty;
 763                                         return (CurrencyManager) this.BindingContext[DataSource, dataMember];
 764                                 }
 765                                 return null;
 766                         }
 767                 }
 768
 769                 [AmbientValue (null)]
 770                 public DataGridViewCellStyle DefaultCellStyle {
 771                         get { return defaultCellStyle; }
 772                         set {
 773                                 if (defaultCellStyle != value) {
 774                                         defaultCellStyle = value;
 775                                         OnDefaultCellStyleChanged(EventArgs.Empty);
 776                                 }
 777                         }
 778                 }
 779
 780                 public override Rectangle DisplayRectangle {
 781                         get { return base.DisplayRectangle; }
 782                 }
 783
 784                 [Browsable (false)]
 785                 [EditorBrowsable (EditorBrowsableState.Advanced)]
 786                 public Control EditingControl {
 787                         get {
 788                                 return editingControl;
 789                         }
 790                 }
 791
 792                 [Browsable (false)]
 793                 [EditorBrowsable (EditorBrowsableState.Advanced)]
 794                 public Panel EditingPanel {
 795                         get { throw new NotImplementedException(); }
 796                 }
 797
 798                 [DefaultValue (DataGridViewEditMode.EditOnKeystrokeOrF2)]
 799                 public DataGridViewEditMode EditMode {
 800                         get { return editMode; }
 801                         set {
 802                                 if (editMode != value) {
 803                                         editMode = value;
 804                                         OnEditModeChanged(EventArgs.Empty);
 805                                 }
 806                         }
 807                 }
 808
 809                 [DefaultValue (true)]
 810                 public bool EnableHeadersVisualStyles {
 811                         get { return enableHeadersVisualStyles; }
 812                         set { enableHeadersVisualStyles = value; }
 813                 }
 814
 815                 internal DataGridViewHeaderCell EnteredHeaderCell {
 816                         get { return entered_header_cell; }
 817                         set {
 818                                 if (entered_header_cell == value)
 819                                         return;
 820                                 if (ThemeEngine.Current.DataGridViewHeaderCellHasHotStyle (this)) {
 821                                         Region area_to_invalidate = new Region ();
 822                                         area_to_invalidate.MakeEmpty ();
 823                                         if (entered_header_cell != null)
 824                                                 area_to_invalidate.Union (GetHeaderCellBounds (entered_header_cell));
 825                                         entered_header_cell = value;
 826                                         if (entered_header_cell != null)
 827                                                 area_to_invalidate.Union (GetHeaderCellBounds (entered_header_cell));
 828                                         Invalidate (area_to_invalidate);
 829                                         area_to_invalidate.Dispose ();
 830                                 } else
 831                                         entered_header_cell = value;
 832                         }
 833                 }
 834
 835                 [Browsable (false)]
 836                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 837                 public DataGridViewCell FirstDisplayedCell {
 838                         get { return firstDisplayedCell; }
 839                         set {
 840                                 if (value.DataGridView != this) {
 841                                         throw new ArgumentException("The cell is not in this DataGridView.");
 842                                 }
 843                                 firstDisplayedCell = value;
 844                         }
 845                 }
 846
 847                 [Browsable (false)]
 848                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 849                 [EditorBrowsable (EditorBrowsableState.Advanced)]
 850                 public int FirstDisplayedScrollingColumnHiddenWidth {
 851                         get { return firstDisplayedScrollingColumnHiddenWidth; }
 852                 }
 853
 854                 [Browsable (false)]
 855                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 856                 public int FirstDisplayedScrollingColumnIndex {
 857                         get { return firstDisplayedScrollingColumnIndex; }
 858                         set { firstDisplayedScrollingColumnIndex = value; }
 859                 }
 860
 861                 [Browsable (false)]
 862                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 863                 public int FirstDisplayedScrollingRowIndex {
 864                         get { return firstDisplayedScrollingRowIndex; }
 865                         set { firstDisplayedScrollingRowIndex = value; }
 866                 }
 867
 868                 [Browsable (false)]
 869                 [EditorBrowsable (EditorBrowsableState.Advanced)]
 870                 public override Font Font {
 871                         get { return base.Font; }
 872                         set { base.Font = value; }
 873                 }
 874
 875                 [Browsable (false)]
 876                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 877                 [EditorBrowsable (EditorBrowsableState.Advanced)]
 878                 public override Color ForeColor {
 879                         get { return base.ForeColor; }
 880                         set { base.ForeColor = value; }
 881                 }
 882
 883                 public Color GridColor {
 884                         get { return gridColor; }
 885                         set {
 886                                 if (gridColor != value) {
 887                                         if (value == Color.Empty) {
 888                                                 throw new ArgumentException("Cant set an Empty color.");
 889                                         }
 890                                         gridColor = value;
 891                                         OnGridColorChanged(EventArgs.Empty);
 892                                 }
 893                         }
 894                 }
 895
 896                 [Browsable (false)]
 897                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 898                 public int HorizontalScrollingOffset {
 899                         get { return horizontalScrollingOffset; }
 900                         set { horizontalScrollingOffset = value; }
 901                 }
 902
 903                 [Browsable (false)]
 904                 public bool IsCurrentCellDirty {
 905                         get { return isCurrentCellDirty; }
 906                 }
 907
 908                 [Browsable (false)]
 909                 public bool IsCurrentCellInEditMode {
 910                         get {
 911                                 if (currentCell == null) {
 912                                         return false;
 913                                 }
 914                                 return currentCell.IsInEditMode;
 915                         }
 916                 }
 917
 918                 [Browsable (false)]
 919                 public bool IsCurrentRowDirty {
 920                         get {
 921                                 if (!virtualMode)
 922                                         return IsCurrentCellDirty;
 923
 924                                 QuestionEventArgs args = new QuestionEventArgs ();
 925                                 OnRowDirtyStateNeeded (args);
 926                                 return args.Response;
 927                         }
 928                 }
 929
 930                 [Browsable (false)]
 931                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 932                 public DataGridViewCell this [int columnIndex, int rowIndex] {
 933                         get { return rows[rowIndex].Cells[columnIndex]; }
 934                         set { rows[rowIndex].Cells[columnIndex] = value; }
 935                 }
 936
 937                 [Browsable (false)]
 938                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 939                 public DataGridViewCell this [string columnName, int rowIndex] {
 940                         get {
 941                                 int columnIndex = -1;
 942                                 foreach (DataGridViewColumn col in columns) {
 943                                         if (col.Name == columnName) {
 944                                                 columnIndex = col.Index;
 945                                                 break;
 946                                         }
 947                                 }
 948                                 return this[columnIndex, rowIndex];
 949                         }
 950                         set {
 951                                 int columnIndex = -1;
 952                                 foreach (DataGridViewColumn col in columns) {
 953                                         if (col.Name == columnName) {
 954                                                 columnIndex = col.Index;
 955                                                 break;
 956                                         }
 957                                 }
 958                                 this[columnIndex, rowIndex] = value;
 959                         }
 960                 }
 961
 962                 [DefaultValue (true)]
 963                 public bool MultiSelect {
 964                         get { return multiSelect; }
 965                         set {
 966                                 if (multiSelect != value) {
 967                                         multiSelect = value;
 968                                         OnMultiSelectChanged(EventArgs.Empty);
 969                                 }
 970                         }
 971                 }
 972
 973                 [Browsable (false)]
 974                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 975                 public int NewRowIndex {
 976                         get {
 977                                 if (!AllowUserToAddRows || ColumnCount == 0) {
 978                                         return -1;
 979                                 }
 980                                 return rows.Count - 1;
 981                         }
 982                 }
 983
 984                 [Browsable (false)]
 985                 [EditorBrowsable (EditorBrowsableState.Never)]
 986                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 987                 public new Padding Padding {
 988                         get { return Padding.Empty; }
 989                         set { }
 990                 }
 991
 992                 internal DataGridViewHeaderCell PressedHeaderCell {
 993                         get { return pressed_header_cell; }
 994                 }
 995
 996                 [Browsable (true)]
 997                 [DefaultValue (false)]
 998                 public bool ReadOnly {
 999                         get { return readOnly; }
1000                         set {
1001                                 if (readOnly != value) {
1002                                         readOnly = value;
1003                                         OnReadOnlyChanged(EventArgs.Empty);
1004                                 }
1005                         }
1006                 }
1007
1008                 [Browsable (false)]
1009                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1010                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
1011                 [DefaultValue (0)]
1012                 public int RowCount {
1013                         get { return rows.Count; }
1014                         set {
1015                                 if (value < 0) {
1016                                         throw new ArgumentException("RowCount must be >= 0.");
1017                                 }
1018                                 if (value < 1 && AllowUserToAddRows) {
1019                                         throw new ArgumentException("RowCount must be >= 1 if AllowUserToAddRows is true.");
1020                                 }
1021                                 if (dataSource != null) {
1022                                         throw new InvalidOperationException("Cant change row count if DataSource is set.");
1023                                 }
1024
1025                                 if (value < rows.Count) {
1026                                         int removeRangeEndIndex = rows.Count - 1;
1027                                         if (AllowUserToAddRows)
1028                                                 removeRangeEndIndex--; // do not remove editing row
1029
1030                                         int removeRangeStartIndex = value - 1;
1031                                         if (AllowUserToAddRows)
1032                                                 removeRangeStartIndex--; // remove an extra row before/instead of the editing row
1033
1034                                         for (int i = removeRangeEndIndex; i > removeRangeStartIndex; i--)
1035                                                 rows.RemoveAt(i);
1036                                 } else if (value > rows.Count) {
1037                                         // If we need to add rows and don't have any columns,
1038                                         // we create one column
1039                                         if (ColumnCount == 0) {
1040                                                 System.Diagnostics.Debug.Assert (rows.Count == 0);
1041                                                 ColumnCount = 1; // this creates the edit row
1042                                                 if (VirtualMode) {
1043                                                         // update edit row height
1044                                                         UpdateRowHeightInfo (0, false);
1045                                                 }
1046                                         }
1047
1048                                         List<DataGridViewRow> newRows = new List<DataGridViewRow> (value - rows.Count);
1049                                         for (int i = rows.Count; i < value; i++)
1050                                                 newRows.Add ((DataGridViewRow) RowTemplateFull);
1051                                         rows.AddRange (newRows.ToArray());
1052                                 }
1053                         }
1054                 }
1055
1056                 [Browsable (true)]
1057                 [DefaultValue (DataGridViewHeaderBorderStyle.Raised)]
1058                 public DataGridViewHeaderBorderStyle RowHeadersBorderStyle {
1059                         get { return rowHeadersBorderStyle; }
1060                         set {
1061                                 if (rowHeadersBorderStyle != value) {
1062                                         rowHeadersBorderStyle = value;
1063                                         OnRowHeadersBorderStyleChanged(EventArgs.Empty);
1064                                 }
1065                         }
1066                 }
1067
1068                 [AmbientValue (null)]
1069                 public DataGridViewCellStyle RowHeadersDefaultCellStyle {
1070                         get { return rowHeadersDefaultCellStyle; }
1071                         set {
1072                                 if (rowHeadersDefaultCellStyle != value) {
1073                                         rowHeadersDefaultCellStyle = value;
1074                                         OnRowHeadersDefaultCellStyleChanged(EventArgs.Empty);
1075                                 }
1076                         }
1077                 }
1078
1079                 [DefaultValue (true)]
1080                 public bool RowHeadersVisible {
1081                         get { return rowHeadersVisible; }
1082                         set {
1083                                 if (rowHeadersVisible != value) {
1084                                         rowHeadersVisible = value;
1085                                         Invalidate ();
1086                                 }
1087                         }
1088                 }
1089
1090                 [Localizable (true)]
1091                 public int RowHeadersWidth {
1092                         get { return rowHeadersWidth; }
1093                         set {
1094                                 if (rowHeadersWidth != value) {
1095                                         if (value < 4) {
1096                                                 throw new ArgumentOutOfRangeException("RowHeadersWidth",
1097                                                         "Row headers width cant be less than 4.");
1098                                         }
1099                                         if (value > 32768 ) {
1100                                                 throw new ArgumentOutOfRangeException("RowHeadersWidth",
1101                                                         "Row headers width cannot be more than 32768.");
1102                                         }
1103                                         rowHeadersWidth = value;
1104                                         OnRowHeadersWidthChanged(EventArgs.Empty);
1105
1106                                         if (rowHeadersVisible)
1107                                                 Invalidate ();
1108                                 }
1109                         }
1110                 }
1111
1112                 [RefreshProperties (RefreshProperties.All)]
1113                 [DefaultValue (DataGridViewRowHeadersWidthSizeMode.EnableResizing)]
1114                 public DataGridViewRowHeadersWidthSizeMode RowHeadersWidthSizeMode {
1115                         get { return rowHeadersWidthSizeMode; }
1116                         set {
1117                                 if (rowHeadersWidthSizeMode != value) {
1118                                         if (!Enum.IsDefined(typeof(DataGridViewRowHeadersWidthSizeMode), value)) {
1119                                                 throw new InvalidEnumArgumentException("Value is not valid DataGridViewRowHeadersWidthSizeMode.");
1120                                         }
1121                                         rowHeadersWidthSizeMode = value;
1122                                         OnRowHeadersWidthSizeModeChanged(new DataGridViewAutoSizeModeEventArgs(false));
1123                                 }
1124                         }
1125                 }
1126
1127                 [Browsable (false)]
1128                 public DataGridViewRowCollection Rows {
1129                         get { return rows; }
1130                 }
1131
1132                 public DataGridViewCellStyle RowsDefaultCellStyle {
1133                         get { return rowsDefaultCellStyle; }
1134                         set {
1135                                 if (rowsDefaultCellStyle != value) {
1136                                         rowsDefaultCellStyle = value;
1137                                         OnRowsDefaultCellStyleChanged(EventArgs.Empty);
1138                                 }
1139                         }
1140                 }
1141
1142                 // RowTemplate is just the row, it does not contain Cells
1143                 [Browsable (true)]
1144                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]
1145                 public DataGridViewRow RowTemplate {
1146                         get {
1147                                 if (rowTemplate == null)
1148                                         rowTemplate = new DataGridViewRow ();
1149
1150                                 return rowTemplate;
1151                         }
1152                         set {
1153                                 rowTemplate = value;
1154                         }
1155                 }
1156
1157                 // Take the RowTemplate, clone it, and add Cells
1158                 // Note this is not stored, so you don't need to Clone it
1159                 internal DataGridViewRow RowTemplateFull {
1160                         get {
1161                                 DataGridViewRow row = (DataGridViewRow) RowTemplate.Clone ();
1162
1163                                 for (int i = row.Cells.Count; i < Columns.Count; i++) {
1164                                         DataGridViewCell template = columns [i].CellTemplate;
1165
1166                                         if (template == null)
1167                                                 throw new InvalidOperationException ("At least one of the DataGridView control's columns has no cell template.");
1168
1169                                         row.Cells.Add ((DataGridViewCell) template.Clone ());
1170                                 }
1171
1172                                 return row;
1173                         }
1174                 }
1175
1176                 internal override bool ScaleChildrenInternal {
1177                         get { return false; }
1178                 }
1179
1180                 [DefaultValue (ScrollBars.Both)]
1181                 [Localizable (true)]
1182                 public ScrollBars ScrollBars {
1183                         get { return scrollBars; }
1184                         set {
1185                                 if (!Enum.IsDefined(typeof(ScrollBars), value)) {
1186                                         throw new InvalidEnumArgumentException("Invalid ScrollBars value.");
1187                                 }
1188                                 ////////////////////////////////////////////////////////////
1189                                 /// *** InvalidOperationException ***
1190                                 /// The System.Windows.Forms.DataGridView is unable to
1191                                 /// scroll due to a cell change that cannot be committed
1192                                 /// or canceled.
1193                                 ///////////////////////////////////////////////////////////
1194                                 scrollBars = value;
1195                                 PerformLayout ();
1196                                 Invalidate ();
1197                         }
1198                 }
1199
1200                 [Browsable (false)]
1201                 public DataGridViewSelectedCellCollection SelectedCells {
1202                         get {
1203                                 DataGridViewSelectedCellCollection selectedCells = new DataGridViewSelectedCellCollection();
1204                                 foreach (DataGridViewRow row in rows) {
1205                                         foreach (DataGridViewCell cell in row.Cells) {
1206                                                 if (cell.Selected) {
1207                                                         selectedCells.InternalAdd(cell);
1208                                                 }
1209                                         }
1210                                 }
1211                                 return selectedCells;
1212                         }
1213                 }
1214
1215                 [Browsable (false)]
1216                 public DataGridViewSelectedColumnCollection SelectedColumns {
1217                         get
1218                         {
1219                                 DataGridViewSelectedColumnCollection result = new DataGridViewSelectedColumnCollection ();
1220
1221                                 if (selectionMode != DataGridViewSelectionMode.FullColumnSelect && selectionMode != DataGridViewSelectionMode.ColumnHeaderSelect)
1222                                         return result;
1223
1224                                 result.InternalAddRange (selected_columns);
1225
1226                                 return result;
1227                         }
1228                 }
1229
1230                 [Browsable (false)]
1231                 public DataGridViewSelectedRowCollection SelectedRows {
1232                         get {
1233                                 DataGridViewSelectedRowCollection result = new DataGridViewSelectedRowCollection (this);
1234
1235                                 if (selectionMode != DataGridViewSelectionMode.FullRowSelect && selectionMode != DataGridViewSelectionMode.RowHeaderSelect)
1236                                         return result;
1237
1238                                 result.InternalAddRange (selected_rows);
1239
1240                                 return result;
1241                         }
1242                 }
1243
1244                 [Browsable (true)]
1245                 [DefaultValue (DataGridViewSelectionMode.RowHeaderSelect)]
1246                 public DataGridViewSelectionMode SelectionMode {
1247                         get { return selectionMode; }
1248                         set {
1249                                 if (!Enum.IsDefined (typeof(DataGridViewSelectionMode), value))
1250                                         throw new InvalidEnumArgumentException ("Value is not valid DataGridViewSelectionMode.");
1251
1252                                 if (value == DataGridViewSelectionMode.ColumnHeaderSelect || value == DataGridViewSelectionMode.FullColumnSelect)
1253                                         foreach (DataGridViewColumn col in Columns)
1254                                                 if (col.SortMode == DataGridViewColumnSortMode.Automatic)
1255                                                         throw new InvalidOperationException (string.Format ("Cannot set SelectionMode to {0} because there are Automatic sort columns.", value));
1256
1257                                 selectionMode = value;
1258                         }
1259                 }
1260
1261                 [DefaultValue (true)]
1262                 public bool ShowCellErrors {
1263                         get { return showCellErrors; }
1264                         set { showCellErrors = value; }
1265                 }
1266
1267                 [DefaultValue (true)]
1268                 public bool ShowCellToolTips {
1269                         get { return showCellToolTips; }
1270                         set { showCellToolTips = value; }
1271                 }
1272
1273                 [DefaultValue (true)]
1274                 public bool ShowEditingIcon {
1275                         get { return showEditingIcon; }
1276                         set { showEditingIcon = value; }
1277                 }
1278
1279                 [DefaultValue (true)]
1280                 public bool ShowRowErrors {
1281                         get { return showRowErrors; }
1282                         set { showRowErrors = value; }
1283                 }
1284
1285                 [Browsable (false)]
1286                 public DataGridViewColumn SortedColumn {
1287                         get { return sortedColumn; }
1288                 }
1289
1290                 [Browsable (false)]
1291                 public SortOrder SortOrder {
1292                         get { return sortOrder; }
1293                 }
1294
1295                 [DefaultValue (false)]
1296                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1297                 public bool StandardTab {
1298                         get { return standardTab; }
1299                         set { standardTab = value; }
1300                 }
1301
1302                 [Bindable (false)]
1303                 [Browsable (false)]
1304                 [EditorBrowsable (EditorBrowsableState.Never)]
1305                 public override string Text {
1306                         get { return base.Text; }
1307                         set { base.Text = value; }
1308                 }
1309
1310                 [Browsable (false)]
1311                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
1312                 public DataGridViewHeaderCell TopLeftHeaderCell {
1313                         get {
1314                                 if (topLeftHeaderCell == null) {
1315                                         topLeftHeaderCell = new DataGridViewTopLeftHeaderCell ();
1316                                         topLeftHeaderCell.SetDataGridView (this);
1317                                 }
1318                                 return topLeftHeaderCell;
1319                         }
1320                         set {
1321                                 if (topLeftHeaderCell == value)
1322                                         return;
1323
1324                                 if (topLeftHeaderCell != null)
1325                                         topLeftHeaderCell.SetDataGridView (null);
1326
1327                                 topLeftHeaderCell = value;
1328
1329                                 if (topLeftHeaderCell != null)
1330                                         topLeftHeaderCell.SetDataGridView (this);
1331                         }
1332                 }
1333
1334                 [Browsable (false)]
1335                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1336                 public Cursor UserSetCursor {
1337                         get { return userSetCursor; }
1338                 }
1339
1340                 [Browsable (false)]
1341                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
1342                 public int VerticalScrollingOffset {
1343                         get { return verticalScrollingOffset; }
1344                 }
1345
1346                 [MonoTODO ("VirtualMode is not supported.")]
1347                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1348                 [DefaultValue (false)]
1349                 public bool VirtualMode {
1350                         get { return virtualMode; }
1351                         set { virtualMode = value; }
1352                 }
1353
1354                 internal Control EditingControlInternal {
1355                         get {
1356                                 return editingControl;
1357                         }
1358                         set {
1359                                 if (value == editingControl)
1360                                         return;
1361
1362                                 if (editingControl != null) {
1363                                         // Can't use Controls.Remove (editingControls), because that method
1364                                         // is overriden to not remove the editing control.
1365                                         DataGridView.DataGridViewControlCollection ctrls = Controls as DataGridView.DataGridViewControlCollection;
1366                                         if (ctrls != null) {
1367                                                 ctrls.RemoveInternal (editingControl);
1368                                         } else {
1369                                                 Controls.Remove (editingControl);
1370                                         }
1371                                         editingControl.Dispose();
1372                                 }
1373
1374
1375                                 if (value != null) {
1376                                         value.Visible = false;
1377                                         Controls.Add (value);
1378                                 }
1379
1380                                 editingControl = value;
1381                         }
1382                 }
1383
1384                 static object AllowUserToAddRowsChangedEvent = new object ();
1385                 static object AllowUserToDeleteRowsChangedEvent = new object ();
1386                 static object AllowUserToOrderColumnsChangedEvent = new object ();
1387                 static object AllowUserToResizeColumnsChangedEvent = new object ();
1388                 static object AllowUserToResizeRowsChangedEvent = new object ();
1389                 static object AlternatingRowsDefaultCellStyleChangedEvent = new object ();
1390                 static object AutoGenerateColumnsChangedEvent = new object ();
1391                 static object AutoSizeColumnModeChangedEvent = new object ();
1392                 static object AutoSizeColumnsModeChangedEvent = new object ();
1393                 static object AutoSizeRowsModeChangedEvent = new object ();
1394                 static object BackgroundColorChangedEvent = new object ();
1395                 static object BorderStyleChangedEvent = new object ();
1396                 static object CancelRowEditEvent = new object ();
1397                 static object CellBeginEditEvent = new object ();
1398                 static object CellBorderStyleChangedEvent = new object ();
1399                 static object CellClickEvent = new object ();
1400                 static object CellContentClickEvent = new object ();
1401                 static object CellContentDoubleClickEvent = new object ();
1402                 static object CellContextMenuStripChangedEvent = new object ();
1403                 static object CellContextMenuStripNeededEvent = new object ();
1404                 static object CellDoubleClickEvent = new object ();
1405                 static object CellEndEditEvent = new object ();
1406                 static object CellEnterEvent = new object ();
1407                 static object CellErrorTextChangedEvent = new object ();
1408                 static object CellErrorTextNeededEvent = new object ();
1409                 static object CellFormattingEvent = new object ();
1410                 static object CellLeaveEvent = new object ();
1411                 static object CellMouseClickEvent = new object ();
1412                 static object CellMouseDoubleClickEvent = new object ();
1413                 static object CellMouseDownEvent = new object ();
1414                 static object CellMouseEnterEvent = new object ();
1415                 static object CellMouseLeaveEvent = new object ();
1416                 static object CellMouseMoveEvent = new object ();
1417                 static object CellMouseUpEvent = new object ();
1418                 static object CellPaintingEvent = new object ();
1419                 static object CellParsingEvent = new object ();
1420                 static object CellStateChangedEvent = new object ();
1421                 static object CellStyleChangedEvent = new object ();
1422                 static object CellStyleContentChangedEvent = new object ();
1423                 static object CellToolTipTextChangedEvent = new object ();
1424                 static object CellToolTipTextNeededEvent = new object ();
1425                 static object CellValidatedEvent = new object ();
1426                 static object CellValidatingEvent = new object ();
1427                 static object CellValueChangedEvent = new object ();
1428                 static object CellValueNeededEvent = new object ();
1429                 static object CellValuePushedEvent = new object ();
1430                 static object ColumnAddedEvent = new object ();
1431                 static object ColumnContextMenuStripChangedEvent = new object ();
1432                 static object ColumnDataPropertyNameChangedEvent = new object ();
1433                 static object ColumnDefaultCellStyleChangedEvent = new object ();
1434                 static object ColumnDisplayIndexChangedEvent = new object ();
1435                 static object ColumnDividerDoubleClickEvent = new object ();
1436                 static object ColumnDividerWidthChangedEvent = new object ();
1437                 static object ColumnHeaderCellChangedEvent = new object ();
1438                 static object ColumnHeaderMouseClickEvent = new object ();
1439                 static object ColumnHeaderMouseDoubleClickEvent = new object ();
1440                 static object ColumnHeadersBorderStyleChangedEvent = new object ();
1441                 static object ColumnHeadersDefaultCellStyleChangedEvent = new object ();
1442                 static object ColumnHeadersHeightChangedEvent = new object ();
1443                 static object ColumnHeadersHeightSizeModeChangedEvent = new object ();
1444                 static object ColumnMinimumWidthChangedEvent = new object ();
1445                 static object ColumnNameChangedEvent = new object ();
1446                 static object ColumnRemovedEvent = new object ();
1447                 static object ColumnSortModeChangedEvent = new object ();
1448                 static object ColumnStateChangedEvent = new object ();
1449                 static object ColumnToolTipTextChangedEvent = new object ();
1450                 static object ColumnWidthChangedEvent = new object ();
1451                 static object CurrentCellChangedEvent = new object ();
1452                 static object CurrentCellDirtyStateChangedEvent = new object ();
1453                 static object DataBindingCompleteEvent = new object ();
1454                 static object DataErrorEvent = new object ();
1455                 static object DataMemberChangedEvent = new object ();
1456                 static object DataSourceChangedEvent = new object ();
1457                 static object DefaultCellStyleChangedEvent = new object ();
1458                 static object DefaultValuesNeededEvent = new object ();
1459                 static object EditingControlShowingEvent = new object ();
1460                 static object EditModeChangedEvent = new object ();
1461                 static object GridColorChangedEvent = new object ();
1462                 static object MultiSelectChangedEvent = new object ();
1463                 static object NewRowNeededEvent = new object ();
1464                 static object ReadOnlyChangedEvent = new object ();
1465                 static object RowContextMenuStripChangedEvent = new object ();
1466                 static object RowContextMenuStripNeededEvent = new object ();
1467                 static object RowDefaultCellStyleChangedEvent = new object ();
1468                 static object RowDirtyStateNeededEvent = new object ();
1469                 static object RowDividerDoubleClickEvent = new object ();
1470                 static object RowDividerHeightChangedEvent = new object ();
1471                 static object RowEnterEvent = new object ();
1472                 static object RowErrorTextChangedEvent = new object ();
1473                 static object RowErrorTextNeededEvent = new object ();
1474                 static object RowHeaderCellChangedEvent = new object ();
1475                 static object RowHeaderMouseClickEvent = new object ();
1476                 static object RowHeaderMouseDoubleClickEvent = new object ();
1477                 static object RowHeadersBorderStyleChangedEvent = new object ();
1478                 static object RowHeadersDefaultCellStyleChangedEvent = new object ();
1479                 static object RowHeadersWidthChangedEvent = new object ();
1480                 static object RowHeadersWidthSizeModeChangedEvent = new object ();
1481                 static object RowHeightChangedEvent = new object ();
1482                 static object RowHeightInfoNeededEvent = new object ();
1483                 static object RowHeightInfoPushedEvent = new object ();
1484                 static object RowLeaveEvent = new object ();
1485                 static object RowMinimumHeightChangedEvent = new object ();
1486                 static object RowPostPaintEvent = new object ();
1487                 static object RowPrePaintEvent = new object ();
1488                 static object RowsAddedEvent = new object ();
1489                 static object RowsDefaultCellStyleChangedEvent = new object ();
1490                 static object RowsRemovedEvent = new object ();
1491                 static object RowStateChangedEvent = new object ();
1492                 static object RowUnsharedEvent = new object ();
1493                 static object RowValidatedEvent = new object ();
1494                 static object RowValidatingEvent = new object ();
1495                 static object ScrollEvent = new object ();
1496                 static object SelectionChangedEvent = new object ();
1497                 static object SortCompareEvent = new object ();
1498                 static object SortedEvent = new object ();
1499                 static object UserAddedRowEvent = new object ();
1500                 static object UserDeletedRowEvent = new object ();
1501                 static object UserDeletingRowEvent = new object ();
1502
1503
1504                 //
1505
1506                 public event EventHandler AllowUserToAddRowsChanged {
1507                         add { Events.AddHandler (AllowUserToAddRowsChangedEvent, value); }
1508                         remove { Events.RemoveHandler (AllowUserToAddRowsChangedEvent, value); }
1509                 }
1510
1511                 public event EventHandler AllowUserToDeleteRowsChanged {
1512                         add { Events.AddHandler (AllowUserToDeleteRowsChangedEvent, value); }
1513                         remove { Events.RemoveHandler (AllowUserToDeleteRowsChangedEvent, value); }
1514                 }
1515
1516                 public event EventHandler AllowUserToOrderColumnsChanged {
1517                         add { Events.AddHandler (AllowUserToOrderColumnsChangedEvent, value); }
1518                         remove { Events.RemoveHandler (AllowUserToOrderColumnsChangedEvent, value); }
1519                 }
1520
1521                 public event EventHandler AllowUserToResizeColumnsChanged {
1522                         add { Events.AddHandler (AllowUserToResizeColumnsChangedEvent, value); }
1523                         remove { Events.RemoveHandler (AllowUserToResizeColumnsChangedEvent, value); }
1524                 }
1525
1526                 public event EventHandler AllowUserToResizeRowsChanged {
1527                         add { Events.AddHandler (AllowUserToResizeRowsChangedEvent, value); }
1528                         remove { Events.RemoveHandler (AllowUserToResizeRowsChangedEvent, value); }
1529                 }
1530
1531                 public event EventHandler AlternatingRowsDefaultCellStyleChanged {
1532                         add { Events.AddHandler (AlternatingRowsDefaultCellStyleChangedEvent, value); }
1533                         remove { Events.RemoveHandler (AlternatingRowsDefaultCellStyleChangedEvent, value); }
1534                 }
1535
1536                 [Browsable (false)]
1537                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1538                 public event EventHandler AutoGenerateColumnsChanged {
1539                         add { Events.AddHandler (AutoGenerateColumnsChangedEvent, value); }
1540                         remove { Events.RemoveHandler (AutoGenerateColumnsChangedEvent, value); }
1541                 }
1542
1543                 public event DataGridViewAutoSizeColumnModeEventHandler AutoSizeColumnModeChanged {
1544                         add { Events.AddHandler (AutoSizeColumnModeChangedEvent, value); }
1545                         remove { Events.RemoveHandler (AutoSizeColumnModeChangedEvent, value); }
1546                 }
1547
1548                 public event DataGridViewAutoSizeColumnsModeEventHandler AutoSizeColumnsModeChanged {
1549                         add { Events.AddHandler (AutoSizeColumnsModeChangedEvent, value); }
1550                         remove { Events.RemoveHandler (AutoSizeColumnsModeChangedEvent, value); }
1551                 }
1552
1553                 public event DataGridViewAutoSizeModeEventHandler AutoSizeRowsModeChanged {
1554                         add { Events.AddHandler (AutoSizeRowsModeChangedEvent, value); }
1555                         remove { Events.RemoveHandler (AutoSizeRowsModeChangedEvent, value); }
1556                 }
1557
1558                 [Browsable (false)]
1559                 [EditorBrowsable (EditorBrowsableState.Never)]
1560                 public new event EventHandler BackColorChanged {
1561                         add { base.BackColorChanged += value; }
1562                         remove { base.BackColorChanged -= value; }
1563                 }
1564
1565                 public event EventHandler BackgroundColorChanged {
1566                         add { Events.AddHandler (BackgroundColorChangedEvent, value); }
1567                         remove { Events.RemoveHandler (BackgroundColorChangedEvent, value); }
1568                 }
1569
1570                 [Browsable (false)]
1571                 [EditorBrowsable (EditorBrowsableState.Never)]
1572                 public new event EventHandler BackgroundImageChanged {
1573                         add { base.BackgroundImageChanged += value; }
1574                         remove { base.BackgroundImageChanged -= value; }
1575                 }
1576
1577                 [Browsable (false)]
1578                 [EditorBrowsable (EditorBrowsableState.Never)]
1579                 public new event EventHandler BackgroundImageLayoutChanged  {
1580                         add { base.BackgroundImageLayoutChanged += value; }
1581                         remove { base.BackgroundImageLayoutChanged -= value; }
1582                 }
1583
1584                 public event EventHandler BorderStyleChanged {
1585                         add { Events.AddHandler (BorderStyleChangedEvent, value); }
1586                         remove { Events.RemoveHandler (BorderStyleChangedEvent, value); }
1587                 }
1588
1589                 public event QuestionEventHandler CancelRowEdit {
1590                         add { Events.AddHandler (CancelRowEditEvent, value); }
1591                         remove { Events.RemoveHandler (CancelRowEditEvent, value); }
1592                 }
1593
1594                 public event DataGridViewCellCancelEventHandler CellBeginEdit {
1595                         add { Events.AddHandler (CellBeginEditEvent, value); }
1596                         remove { Events.RemoveHandler (CellBeginEditEvent, value); }
1597                 }
1598
1599                 public event EventHandler CellBorderStyleChanged {
1600                         add { Events.AddHandler (CellBorderStyleChangedEvent, value); }
1601                         remove { Events.RemoveHandler (CellBorderStyleChangedEvent, value); }
1602                 }
1603
1604                 public event DataGridViewCellEventHandler CellClick {
1605                         add { Events.AddHandler (CellClickEvent, value); }
1606                         remove { Events.RemoveHandler (CellClickEvent, value); }
1607                 }
1608
1609                 public event DataGridViewCellEventHandler CellContentClick {
1610                         add { Events.AddHandler (CellContentClickEvent, value); }
1611                         remove { Events.RemoveHandler (CellContentClickEvent, value); }
1612                 }
1613
1614                 public event DataGridViewCellEventHandler CellContentDoubleClick {
1615                         add { Events.AddHandler (CellContentDoubleClickEvent, value); }
1616                         remove { Events.RemoveHandler (CellContentDoubleClickEvent, value); }
1617                 }
1618
1619                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1620                 public event DataGridViewCellEventHandler CellContextMenuStripChanged {
1621                         add { Events.AddHandler (CellContextMenuStripChangedEvent, value); }
1622                         remove { Events.RemoveHandler (CellContextMenuStripChangedEvent, value); }
1623                 }
1624
1625                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1626                 public event DataGridViewCellContextMenuStripNeededEventHandler CellContextMenuStripNeeded {
1627                         add { Events.AddHandler (CellContextMenuStripNeededEvent, value); }
1628                         remove { Events.RemoveHandler (CellContextMenuStripNeededEvent, value); }
1629                 }
1630
1631                 public event DataGridViewCellEventHandler CellDoubleClick {
1632                         add { Events.AddHandler (CellDoubleClickEvent, value); }
1633                         remove { Events.RemoveHandler (CellDoubleClickEvent, value); }
1634                 }
1635
1636                 public event DataGridViewCellEventHandler CellEndEdit {
1637                         add { Events.AddHandler (CellEndEditEvent, value); }
1638                         remove { Events.RemoveHandler (CellEndEditEvent, value); }
1639                 }
1640
1641                 public event DataGridViewCellEventHandler CellEnter {
1642                         add { Events.AddHandler (CellEnterEvent, value); }
1643                         remove { Events.RemoveHandler (CellEnterEvent, value); }
1644                 }
1645
1646                 public event DataGridViewCellEventHandler CellErrorTextChanged {
1647                         add { Events.AddHandler (CellErrorTextChangedEvent, value); }
1648                         remove { Events.RemoveHandler (CellErrorTextChangedEvent, value); }
1649                 }
1650
1651                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1652                 public event DataGridViewCellErrorTextNeededEventHandler CellErrorTextNeeded {
1653                         add { Events.AddHandler (CellErrorTextNeededEvent, value); }
1654                         remove { Events.RemoveHandler (CellErrorTextNeededEvent, value); }
1655                 }
1656
1657                 public event DataGridViewCellFormattingEventHandler CellFormatting {
1658                         add { Events.AddHandler (CellFormattingEvent, value); }
1659                         remove { Events.RemoveHandler (CellFormattingEvent, value); }
1660                 }
1661
1662                 public event DataGridViewCellEventHandler CellLeave {
1663                         add { Events.AddHandler (CellLeaveEvent, value); }
1664                         remove { Events.RemoveHandler (CellLeaveEvent, value); }
1665                 }
1666
1667                 public event DataGridViewCellMouseEventHandler CellMouseClick {
1668                         add { Events.AddHandler (CellMouseClickEvent, value); }
1669                         remove { Events.RemoveHandler (CellMouseClickEvent, value); }
1670                 }
1671
1672                 public event DataGridViewCellMouseEventHandler CellMouseDoubleClick {
1673                         add { Events.AddHandler (CellMouseDoubleClickEvent, value); }
1674                         remove { Events.RemoveHandler (CellMouseDoubleClickEvent, value); }
1675                 }
1676
1677                 public event DataGridViewCellMouseEventHandler CellMouseDown {
1678                         add { Events.AddHandler (CellMouseDownEvent, value); }
1679                         remove { Events.RemoveHandler (CellMouseDownEvent, value); }
1680                 }
1681
1682                 public event DataGridViewCellEventHandler CellMouseEnter {
1683                         add { Events.AddHandler (CellMouseEnterEvent, value); }
1684                         remove { Events.RemoveHandler (CellMouseEnterEvent, value); }
1685                 }
1686
1687                 public event DataGridViewCellEventHandler CellMouseLeave {
1688                         add { Events.AddHandler (CellMouseLeaveEvent, value); }
1689                         remove { Events.RemoveHandler (CellMouseLeaveEvent, value); }
1690                 }
1691
1692                 public event DataGridViewCellMouseEventHandler CellMouseMove {
1693                         add { Events.AddHandler (CellMouseMoveEvent, value); }
1694                         remove { Events.RemoveHandler (CellMouseMoveEvent, value); }
1695                 }
1696
1697                 public event DataGridViewCellMouseEventHandler CellMouseUp {
1698                         add { Events.AddHandler (CellMouseUpEvent, value); }
1699                         remove { Events.RemoveHandler (CellMouseUpEvent, value); }
1700                 }
1701
1702                 public event DataGridViewCellPaintingEventHandler CellPainting {
1703                         add { Events.AddHandler (CellPaintingEvent, value); }
1704                         remove { Events.RemoveHandler (CellPaintingEvent, value); }
1705                 }
1706
1707                 public event DataGridViewCellParsingEventHandler CellParsing {
1708                         add { Events.AddHandler (CellParsingEvent, value); }
1709                         remove { Events.RemoveHandler (CellParsingEvent, value); }
1710                 }
1711
1712                 public event DataGridViewCellStateChangedEventHandler CellStateChanged {
1713                         add { Events.AddHandler (CellStateChangedEvent, value); }
1714                         remove { Events.RemoveHandler (CellStateChangedEvent, value); }
1715                 }
1716
1717                 public event DataGridViewCellEventHandler CellStyleChanged {
1718                         add { Events.AddHandler (CellStyleChangedEvent, value); }
1719                         remove { Events.RemoveHandler (CellStyleChangedEvent, value); }
1720                 }
1721
1722                 public event DataGridViewCellStyleContentChangedEventHandler CellStyleContentChanged {
1723                         add { Events.AddHandler (CellStyleContentChangedEvent, value); }
1724                         remove { Events.RemoveHandler (CellStyleContentChangedEvent, value); }
1725                 }
1726
1727                 public event DataGridViewCellEventHandler CellToolTipTextChanged {
1728                         add { Events.AddHandler (CellToolTipTextChangedEvent, value); }
1729                         remove { Events.RemoveHandler (CellToolTipTextChangedEvent, value); }
1730                 }
1731
1732                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1733                 public event DataGridViewCellToolTipTextNeededEventHandler CellToolTipTextNeeded {
1734                         add { Events.AddHandler (CellToolTipTextNeededEvent, value); }
1735                         remove { Events.RemoveHandler (CellToolTipTextNeededEvent, value); }
1736                 }
1737
1738                 public event DataGridViewCellEventHandler CellValidated {
1739                         add { Events.AddHandler (CellValidatedEvent, value); }
1740                         remove { Events.RemoveHandler (CellValidatedEvent, value); }
1741                 }
1742
1743                 public event DataGridViewCellValidatingEventHandler CellValidating {
1744                         add { Events.AddHandler (CellValidatingEvent, value); }
1745                         remove { Events.RemoveHandler (CellValidatingEvent, value); }
1746                 }
1747
1748                 public event DataGridViewCellEventHandler CellValueChanged {
1749                         add { Events.AddHandler (CellValueChangedEvent, value); }
1750                         remove { Events.RemoveHandler (CellValueChangedEvent, value); }
1751                 }
1752
1753                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1754                 public event DataGridViewCellValueEventHandler CellValueNeeded {
1755                         add { Events.AddHandler (CellValueNeededEvent, value); }
1756                         remove { Events.RemoveHandler (CellValueNeededEvent, value); }
1757                 }
1758
1759                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1760                 public event DataGridViewCellValueEventHandler CellValuePushed {
1761                         add { Events.AddHandler (CellValuePushedEvent, value); }
1762                         remove { Events.RemoveHandler (CellValuePushedEvent, value); }
1763                 }
1764
1765                 public event DataGridViewColumnEventHandler ColumnAdded {
1766                         add { Events.AddHandler (ColumnAddedEvent, value); }
1767                         remove { Events.RemoveHandler (ColumnAddedEvent, value); }
1768                 }
1769
1770                 public event DataGridViewColumnEventHandler ColumnContextMenuStripChanged {
1771                         add { Events.AddHandler (ColumnContextMenuStripChangedEvent, value); }
1772                         remove { Events.RemoveHandler (ColumnContextMenuStripChangedEvent, value); }
1773                 }
1774
1775                 public event DataGridViewColumnEventHandler ColumnDataPropertyNameChanged {
1776                         add { Events.AddHandler (ColumnDataPropertyNameChangedEvent, value); }
1777                         remove { Events.RemoveHandler (ColumnDataPropertyNameChangedEvent, value); }
1778                 }
1779
1780                 public event DataGridViewColumnEventHandler ColumnDefaultCellStyleChanged {
1781                         add { Events.AddHandler (ColumnDefaultCellStyleChangedEvent, value); }
1782                         remove { Events.RemoveHandler (ColumnDefaultCellStyleChangedEvent, value); }
1783                 }
1784
1785                 public event DataGridViewColumnEventHandler ColumnDisplayIndexChanged {
1786                         add { Events.AddHandler (ColumnDisplayIndexChangedEvent, value); }
1787                         remove { Events.RemoveHandler (ColumnDisplayIndexChangedEvent, value); }
1788                 }
1789
1790                 public event DataGridViewColumnDividerDoubleClickEventHandler ColumnDividerDoubleClick {
1791                         add { Events.AddHandler (ColumnDividerDoubleClickEvent, value); }
1792                         remove { Events.RemoveHandler (ColumnDividerDoubleClickEvent, value); }
1793                 }
1794
1795                 public event DataGridViewColumnEventHandler ColumnDividerWidthChanged {
1796                         add { Events.AddHandler (ColumnDividerWidthChangedEvent, value); }
1797                         remove { Events.RemoveHandler (ColumnDividerWidthChangedEvent, value); }
1798                 }
1799
1800                 public event DataGridViewColumnEventHandler ColumnHeaderCellChanged {
1801                         add { Events.AddHandler (ColumnHeaderCellChangedEvent, value); }
1802                         remove { Events.RemoveHandler (ColumnHeaderCellChangedEvent, value); }
1803                 }
1804
1805                 public event DataGridViewCellMouseEventHandler ColumnHeaderMouseClick {
1806                         add { Events.AddHandler (ColumnHeaderMouseClickEvent, value); }
1807                         remove { Events.RemoveHandler (ColumnHeaderMouseClickEvent, value); }
1808                 }
1809
1810                 public event DataGridViewCellMouseEventHandler ColumnHeaderMouseDoubleClick {
1811                         add { Events.AddHandler (ColumnHeaderMouseDoubleClickEvent, value); }
1812                         remove { Events.RemoveHandler (ColumnHeaderMouseDoubleClickEvent, value); }
1813                 }
1814
1815                 public event EventHandler ColumnHeadersBorderStyleChanged {
1816                         add { Events.AddHandler (ColumnHeadersBorderStyleChangedEvent, value); }
1817                         remove { Events.RemoveHandler (ColumnHeadersBorderStyleChangedEvent, value); }
1818                 }
1819
1820                 public event EventHandler ColumnHeadersDefaultCellStyleChanged {
1821                         add { Events.AddHandler (ColumnHeadersDefaultCellStyleChangedEvent, value); }
1822                         remove { Events.RemoveHandler (ColumnHeadersDefaultCellStyleChangedEvent, value); }
1823                 }
1824
1825                 public event EventHandler ColumnHeadersHeightChanged {
1826                         add { Events.AddHandler (ColumnHeadersHeightChangedEvent, value); }
1827                         remove { Events.RemoveHandler (ColumnHeadersHeightChangedEvent, value); }
1828                 }
1829
1830                 public event DataGridViewAutoSizeModeEventHandler ColumnHeadersHeightSizeModeChanged {
1831                         add { Events.AddHandler (ColumnHeadersHeightSizeModeChangedEvent, value); }
1832                         remove { Events.RemoveHandler (ColumnHeadersHeightSizeModeChangedEvent, value); }
1833                 }
1834
1835                 public event DataGridViewColumnEventHandler ColumnMinimumWidthChanged {
1836                         add { Events.AddHandler (ColumnMinimumWidthChangedEvent, value); }
1837                         remove { Events.RemoveHandler (ColumnMinimumWidthChangedEvent, value); }
1838                 }
1839
1840                 public event DataGridViewColumnEventHandler ColumnNameChanged {
1841                         add { Events.AddHandler (ColumnNameChangedEvent, value); }
1842                         remove { Events.RemoveHandler (ColumnNameChangedEvent, value); }
1843                 }
1844
1845                 public event DataGridViewColumnEventHandler ColumnRemoved {
1846                         add { Events.AddHandler (ColumnRemovedEvent, value); }
1847                         remove { Events.RemoveHandler (ColumnRemovedEvent, value); }
1848                 }
1849
1850                 public event DataGridViewColumnEventHandler ColumnSortModeChanged {
1851                         add { Events.AddHandler (ColumnSortModeChangedEvent, value); }
1852                         remove { Events.RemoveHandler (ColumnSortModeChangedEvent, value); }
1853                 }
1854
1855                 public event DataGridViewColumnStateChangedEventHandler ColumnStateChanged {
1856                         add { Events.AddHandler (ColumnStateChangedEvent, value); }
1857                         remove { Events.RemoveHandler (ColumnStateChangedEvent, value); }
1858                 }
1859
1860                 public event DataGridViewColumnEventHandler ColumnToolTipTextChanged {
1861                         add { Events.AddHandler (ColumnToolTipTextChangedEvent, value); }
1862                         remove { Events.RemoveHandler (ColumnToolTipTextChangedEvent, value); }
1863                 }
1864
1865                 public event DataGridViewColumnEventHandler ColumnWidthChanged {
1866                         add { Events.AddHandler (ColumnWidthChangedEvent, value); }
1867                         remove { Events.RemoveHandler (ColumnWidthChangedEvent, value); }
1868                 }
1869
1870                 public event EventHandler CurrentCellChanged {
1871                         add { Events.AddHandler (CurrentCellChangedEvent, value); }
1872                         remove { Events.RemoveHandler (CurrentCellChangedEvent, value); }
1873                 }
1874
1875                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1876                 public event EventHandler CurrentCellDirtyStateChanged {
1877                         add { Events.AddHandler (CurrentCellDirtyStateChangedEvent, value); }
1878                         remove { Events.RemoveHandler (CurrentCellDirtyStateChangedEvent, value); }
1879                 }
1880
1881                 public event DataGridViewBindingCompleteEventHandler DataBindingComplete {
1882                         add { Events.AddHandler (DataBindingCompleteEvent, value); }
1883                         remove { Events.RemoveHandler (DataBindingCompleteEvent, value); }
1884                 }
1885
1886                 public event DataGridViewDataErrorEventHandler DataError {
1887                         add { Events.AddHandler (DataErrorEvent, value); }
1888                         remove { Events.RemoveHandler (DataErrorEvent, value); }
1889                 }
1890
1891                 public event EventHandler DataMemberChanged {
1892                         add { Events.AddHandler (DataMemberChangedEvent, value); }
1893                         remove { Events.RemoveHandler (DataMemberChangedEvent, value); }
1894                 }
1895
1896                 public event EventHandler DataSourceChanged {
1897                         add { Events.AddHandler (DataSourceChangedEvent, value); }
1898                         remove { Events.RemoveHandler (DataSourceChangedEvent, value); }
1899                 }
1900
1901                 public event EventHandler DefaultCellStyleChanged {
1902                         add { Events.AddHandler (DefaultCellStyleChangedEvent, value); }
1903                         remove { Events.RemoveHandler (DefaultCellStyleChangedEvent, value); }
1904                 }
1905
1906                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1907                 public event DataGridViewRowEventHandler DefaultValuesNeeded {
1908                         add { Events.AddHandler (DefaultValuesNeededEvent, value); }
1909                         remove { Events.RemoveHandler (DefaultValuesNeededEvent, value); }
1910                 }
1911
1912                 public event DataGridViewEditingControlShowingEventHandler EditingControlShowing {
1913                         add { Events.AddHandler (EditingControlShowingEvent, value); }
1914                         remove { Events.RemoveHandler (EditingControlShowingEvent, value); }
1915                 }
1916
1917                 public event EventHandler EditModeChanged {
1918                         add { Events.AddHandler (EditModeChangedEvent, value); }
1919                         remove { Events.RemoveHandler (EditModeChangedEvent, value); }
1920                 }
1921
1922                 [Browsable (false)]
1923                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1924                 public new event EventHandler FontChanged {
1925                         add { base.FontChanged += value; }
1926                         remove { base.FontChanged -= value; }
1927                 }
1928
1929                 [Browsable (false)]
1930                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1931                 public new event EventHandler ForeColorChanged {
1932                         add { base.ForeColorChanged += value; }
1933                         remove { base.ForeColorChanged -= value; }
1934                 }
1935
1936                 [Browsable (false)]
1937                 [EditorBrowsable (EditorBrowsableState.Never)]
1938                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
1939                 public new event EventHandler PaddingChanged {
1940                         add { base.PaddingChanged += value; }
1941                         remove { base.PaddingChanged -= value; }
1942                 }
1943
1944                 public event EventHandler GridColorChanged {
1945                         add { Events.AddHandler (GridColorChangedEvent, value); }
1946                         remove { Events.RemoveHandler (GridColorChangedEvent, value); }
1947                 }
1948
1949                 public event EventHandler MultiSelectChanged {
1950                         add { Events.AddHandler (MultiSelectChangedEvent, value); }
1951                         remove { Events.RemoveHandler (MultiSelectChangedEvent, value); }
1952                 }
1953
1954                 public event DataGridViewRowEventHandler NewRowNeeded {
1955                         add { Events.AddHandler (NewRowNeededEvent, value); }
1956                         remove { Events.RemoveHandler (NewRowNeededEvent, value); }
1957                 }
1958
1959                 public event EventHandler ReadOnlyChanged {
1960                         add { Events.AddHandler (ReadOnlyChangedEvent, value); }
1961                         remove { Events.RemoveHandler (ReadOnlyChangedEvent, value); }
1962                 }
1963
1964                 public event DataGridViewRowEventHandler RowContextMenuStripChanged {
1965                         add { Events.AddHandler (RowContextMenuStripChangedEvent, value); }
1966                         remove { Events.RemoveHandler (RowContextMenuStripChangedEvent, value); }
1967                 }
1968
1969                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1970                 public event DataGridViewRowContextMenuStripNeededEventHandler RowContextMenuStripNeeded {
1971                         add { Events.AddHandler (RowContextMenuStripNeededEvent, value); }
1972                         remove { Events.RemoveHandler (RowContextMenuStripNeededEvent, value); }
1973                 }
1974
1975                 public event DataGridViewRowEventHandler RowDefaultCellStyleChanged {
1976                         add { Events.AddHandler (RowDefaultCellStyleChangedEvent, value); }
1977                         remove { Events.RemoveHandler (RowDefaultCellStyleChangedEvent, value); }
1978                 }
1979
1980                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1981                 public event QuestionEventHandler RowDirtyStateNeeded {
1982                         add { Events.AddHandler (RowDirtyStateNeededEvent, value); }
1983                         remove { Events.RemoveHandler (RowDirtyStateNeededEvent, value); }
1984                 }
1985
1986                 public event DataGridViewRowDividerDoubleClickEventHandler RowDividerDoubleClick {
1987                         add { Events.AddHandler (RowDividerDoubleClickEvent, value); }
1988                         remove { Events.RemoveHandler (RowDividerDoubleClickEvent, value); }
1989                 }
1990
1991                 public event DataGridViewRowEventHandler RowDividerHeightChanged {
1992                         add { Events.AddHandler (RowDividerHeightChangedEvent, value); }
1993                         remove { Events.RemoveHandler (RowDividerHeightChangedEvent, value); }
1994                 }
1995
1996                 public event DataGridViewCellEventHandler RowEnter {
1997                         add { Events.AddHandler (RowEnterEvent, value); }
1998                         remove { Events.RemoveHandler (RowEnterEvent, value); }
1999                 }
2000
2001                 public event DataGridViewRowEventHandler RowErrorTextChanged {
2002                         add { Events.AddHandler (RowErrorTextChangedEvent, value); }
2003                         remove { Events.RemoveHandler (RowErrorTextChangedEvent, value); }
2004                 }
2005
2006                 [EditorBrowsable (EditorBrowsableState.Advanced)]
2007                 public event DataGridViewRowErrorTextNeededEventHandler RowErrorTextNeeded {
2008                         add { Events.AddHandler (RowErrorTextNeededEvent, value); }
2009                         remove { Events.RemoveHandler (RowErrorTextNeededEvent, value); }
2010                 }
2011
2012                 public event DataGridViewRowEventHandler RowHeaderCellChanged {
2013                         add { Events.AddHandler (RowHeaderCellChangedEvent, value); }
2014                         remove { Events.RemoveHandler (RowHeaderCellChangedEvent, value); }
2015                 }
2016
2017                 public event DataGridViewCellMouseEventHandler RowHeaderMouseClick {
2018                         add { Events.AddHandler (RowHeaderMouseClickEvent, value); }
2019                         remove { Events.RemoveHandler (RowHeaderMouseClickEvent, value); }
2020                 }
2021
2022                 public event DataGridViewCellMouseEventHandler RowHeaderMouseDoubleClick {
2023                         add { Events.AddHandler (RowHeaderMouseDoubleClickEvent, value); }
2024                         remove { Events.RemoveHandler (RowHeaderMouseDoubleClickEvent, value); }
2025                 }
2026
2027                 public event EventHandler RowHeadersBorderStyleChanged {
2028                         add { Events.AddHandler (RowHeadersBorderStyleChangedEvent, value); }
2029                         remove { Events.RemoveHandler (RowHeadersBorderStyleChangedEvent, value); }
2030                 }
2031
2032                 public event EventHandler RowHeadersDefaultCellStyleChanged {
2033                         add { Events.AddHandler (RowHeadersDefaultCellStyleChangedEvent, value); }
2034                         remove { Events.RemoveHandler (RowHeadersDefaultCellStyleChangedEvent, value); }
2035                 }
2036
2037                 public event EventHandler RowHeadersWidthChanged {
2038                         add { Events.AddHandler (RowHeadersWidthChangedEvent, value); }
2039                         remove { Events.RemoveHandler (RowHeadersWidthChangedEvent, value); }
2040                 }
2041
2042                 public event DataGridViewAutoSizeModeEventHandler RowHeadersWidthSizeModeChanged {
2043                         add { Events.AddHandler (RowHeadersWidthSizeModeChangedEvent, value); }
2044                         remove { Events.RemoveHandler (RowHeadersWidthSizeModeChangedEvent, value); }
2045                 }
2046
2047                 public event DataGridViewRowEventHandler RowHeightChanged {
2048                         add { Events.AddHandler (RowHeightChangedEvent, value); }
2049                         remove { Events.RemoveHandler (RowHeightChangedEvent, value); }
2050                 }
2051
2052                 [EditorBrowsable (EditorBrowsableState.Advanced)]
2053                 public event DataGridViewRowHeightInfoNeededEventHandler RowHeightInfoNeeded {
2054                         add { Events.AddHandler (RowHeightInfoNeededEvent, value); }
2055                         remove { Events.RemoveHandler (RowHeightInfoNeededEvent, value); }
2056                 }
2057
2058                 [EditorBrowsable (EditorBrowsableState.Advanced)]
2059                 public event DataGridViewRowHeightInfoPushedEventHandler RowHeightInfoPushed {
2060                         add { Events.AddHandler (RowHeightInfoPushedEvent, value); }
2061                         remove { Events.RemoveHandler (RowHeightInfoPushedEvent, value); }
2062                 }
2063
2064                 public event DataGridViewCellEventHandler RowLeave {
2065                         add { Events.AddHandler (RowLeaveEvent, value); }
2066                         remove { Events.RemoveHandler (RowLeaveEvent, value); }
2067                 }
2068
2069                 public event DataGridViewRowEventHandler RowMinimumHeightChanged {
2070                         add { Events.AddHandler (RowMinimumHeightChangedEvent, value); }
2071                         remove { Events.RemoveHandler (RowMinimumHeightChangedEvent, value); }
2072                 }
2073
2074                 public event DataGridViewRowPostPaintEventHandler RowPostPaint {
2075                         add { Events.AddHandler (RowPostPaintEvent, value); }
2076                         remove { Events.RemoveHandler (RowPostPaintEvent, value); }
2077                 }
2078
2079                 public event DataGridViewRowPrePaintEventHandler RowPrePaint {
2080                         add { Events.AddHandler (RowPrePaintEvent, value); }
2081                         remove { Events.RemoveHandler (RowPrePaintEvent, value); }
2082                 }
2083
2084                 public event DataGridViewRowsAddedEventHandler RowsAdded {
2085                         add { Events.AddHandler (RowsAddedEvent, value); }
2086                         remove { Events.RemoveHandler (RowsAddedEvent, value); }
2087                 }
2088
2089                 public event EventHandler RowsDefaultCellStyleChanged {
2090                         add { Events.AddHandler (RowsDefaultCellStyleChangedEvent, value); }
2091                         remove { Events.RemoveHandler (RowsDefaultCellStyleChangedEvent, value); }
2092                 }
2093
2094                 public event DataGridViewRowsRemovedEventHandler RowsRemoved {
2095                         add { Events.AddHandler (RowsRemovedEvent, value); }
2096                         remove { Events.RemoveHandler (RowsRemovedEvent, value); }
2097                 }
2098
2099                 public event DataGridViewRowStateChangedEventHandler RowStateChanged {
2100                         add { Events.AddHandler (RowStateChangedEvent, value); }
2101                         remove { Events.RemoveHandler (RowStateChangedEvent, value); }
2102                 }
2103
2104                 [EditorBrowsable (EditorBrowsableState.Advanced)]
2105                 public event DataGridViewRowEventHandler RowUnshared {
2106                         add { Events.AddHandler (RowUnsharedEvent, value); }
2107                         remove { Events.RemoveHandler (RowUnsharedEvent, value); }
2108                 }
2109
2110                 public event DataGridViewCellEventHandler RowValidated {
2111                         add { Events.AddHandler (RowValidatedEvent, value); }
2112                         remove { Events.RemoveHandler (RowValidatedEvent, value); }
2113                 }
2114
2115                 public event DataGridViewCellCancelEventHandler RowValidating {
2116                         add { Events.AddHandler (RowValidatingEvent, value); }
2117                         remove { Events.RemoveHandler (RowValidatingEvent, value); }
2118                 }
2119
2120                 public event ScrollEventHandler Scroll {
2121                         add { Events.AddHandler (ScrollEvent, value); }
2122                         remove { Events.RemoveHandler (ScrollEvent, value); }
2123                 }
2124
2125                 public event EventHandler SelectionChanged {
2126                         add { Events.AddHandler (SelectionChangedEvent, value); }
2127                         remove { Events.RemoveHandler (SelectionChangedEvent, value); }
2128                 }
2129
2130                 [EditorBrowsable (EditorBrowsableState.Advanced)]
2131                 public event DataGridViewSortCompareEventHandler SortCompare {
2132                         add { Events.AddHandler (SortCompareEvent, value); }
2133                         remove { Events.RemoveHandler (SortCompareEvent, value); }
2134                 }
2135
2136                 public event EventHandler Sorted {
2137                         add { Events.AddHandler (SortedEvent, value); }
2138                         remove { Events.RemoveHandler (SortedEvent, value); }
2139                 }
2140
2141                 public event DataGridViewRowEventHandler UserAddedRow {
2142                         add { Events.AddHandler (UserAddedRowEvent, value); }
2143                         remove { Events.RemoveHandler (UserAddedRowEvent, value); }
2144                 }
2145
2146                 public event DataGridViewRowEventHandler UserDeletedRow {
2147                         add { Events.AddHandler (UserDeletedRowEvent, value); }
2148                         remove { Events.RemoveHandler (UserDeletedRowEvent, value); }
2149                 }
2150
2151                 public event DataGridViewRowCancelEventHandler UserDeletingRow {
2152                         add { Events.AddHandler (UserDeletingRowEvent, value); }
2153                         remove { Events.RemoveHandler (UserDeletingRowEvent, value); }
2154                 }
2155
2156                 [Browsable (false)]
2157                 [EditorBrowsable (EditorBrowsableState.Never)]
2158                 public new event EventHandler StyleChanged {
2159                         add { base.StyleChanged += value; }
2160                         remove { base.StyleChanged -= value; }
2161                 }
2162
2163                 [Browsable (false)]
2164                 [EditorBrowsable (EditorBrowsableState.Never)]
2165                 public new event EventHandler TextChanged {
2166                         add { base.TextChanged += value; }
2167                         remove { base.TextChanged -= value; }
2168                 }
2169
2170                 [EditorBrowsable (EditorBrowsableState.Advanced)]
2171                 public virtual DataGridViewAdvancedBorderStyle AdjustColumnHeaderBorderStyle (DataGridViewAdvancedBorderStyle dataGridViewAdvancedBorderStyleInput, DataGridViewAdvancedBorderStyle dataGridViewAdvancedBorderStylePlaceholder, bool isFirstDisplayedColumn, bool isLastVisibleColumn) {
2172                         return (DataGridViewAdvancedBorderStyle) ((ICloneable)dataGridViewAdvancedBorderStyleInput).Clone();
2173                 }
2174
2175                 public bool AreAllCellsSelected (bool includeInvisibleCells) {
2176                         foreach (DataGridViewRow row in rows) {
2177                                 foreach (DataGridViewCell cell in row.Cells) {
2178                                         if (includeInvisibleCells == false && cell.Visible == false) {
2179                                                 continue;
2180                                         }
2181                                         if (!cell.Selected) {
2182                                                 return false;
2183                                         }
2184                                 }
2185                         }
2186                         return true;
2187                 }
2188
2189                 public void AutoResizeColumn (int columnIndex) {
2190                         AutoResizeColumn (columnIndex, DataGridViewAutoSizeColumnMode.AllCells);
2191                 }
2192
2193                 public void AutoResizeColumn (int columnIndex, DataGridViewAutoSizeColumnMode autoSizeColumnMode)
2194                 {
2195                         AutoResizeColumnInternal (columnIndex, autoSizeColumnMode);
2196                 }
2197
2198                 public void AutoResizeColumnHeadersHeight ()
2199                 {
2200                         int new_height = 0;
2201
2202                         foreach (DataGridViewColumn col in Columns)
2203                                 new_height = Math.Max (new_height, col.HeaderCell.PreferredSize.Height);
2204
2205                         if (ColumnHeadersHeight != new_height)
2206                                 ColumnHeadersHeight = new_height;
2207                 }
2208
2209                 [MonoTODO ("columnIndex parameter is not used")]
2210                 public void AutoResizeColumnHeadersHeight (int columnIndex)
2211                 {
2212                         AutoResizeColumnHeadersHeight ();
2213                 }
2214
2215                 public void AutoResizeColumns () {
2216                         AutoResizeColumns (DataGridViewAutoSizeColumnsMode.AllCells);
2217                 }
2218
2219                 public void AutoResizeColumns (DataGridViewAutoSizeColumnsMode autoSizeColumnsMode) {
2220                         AutoResizeColumns (autoSizeColumnsMode, true);
2221                 }
2222
2223                 public void AutoResizeRow (int rowIndex)
2224                 {
2225                         AutoResizeRow (rowIndex, DataGridViewAutoSizeRowMode.AllCells, true);
2226                 }
2227
2228                 public void AutoResizeRow (int rowIndex, DataGridViewAutoSizeRowMode autoSizeRowMode)
2229                 {
2230                         AutoResizeRow (rowIndex, autoSizeRowMode, true);
2231                 }
2232
2233                 public void AutoResizeRowHeadersWidth (DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode)
2234                 {
2235                         if (rowHeadersWidthSizeMode == DataGridViewRowHeadersWidthSizeMode.AutoSizeToFirstHeader) {
2236                                 RowHeadersWidth = GetRowInternal (0).HeaderCell.PreferredSize.Width;
2237                                 return;
2238                         }
2239
2240                         int new_width = 0;
2241
2242                         if (rowHeadersWidthSizeMode == DataGridViewRowHeadersWidthSizeMode.AutoSizeToDisplayedHeaders) {
2243                                 bool anyRowsDisplayed = false;
2244                                 foreach(DataGridViewRow row in Rows)
2245                                         if(row.Displayed) {
2246                                                 anyRowsDisplayed = true;
2247                                                 new_width = Math.Max (new_width, row.HeaderCell.PreferredSize.Width);
2248                                         }
2249
2250                                 // if there are no rows which are displayed, we still have to set new_width
2251                                 // to a value >= 4 as RowHeadersWidth will throw an exception otherwise
2252                                 if(!anyRowsDisplayed) {
2253                                         foreach (DataGridViewRow row in Rows)
2254                                                         new_width = Math.Max (new_width, row.HeaderCell.PreferredSize.Width);
2255                                 }
2256
2257                                 if (RowHeadersWidth != new_width)
2258                                         RowHeadersWidth = new_width;
2259
2260                                 return;
2261                         }
2262
2263                         if (rowHeadersWidthSizeMode == DataGridViewRowHeadersWidthSizeMode.AutoSizeToAllHeaders) {
2264                                 foreach (DataGridViewRow row in Rows)
2265                                         new_width = Math.Max (new_width, row.HeaderCell.PreferredSize.Width);
2266
2267                                 if (RowHeadersWidth != new_width)
2268                                         RowHeadersWidth = new_width;
2269
2270                                 return;
2271                         }
2272                 }
2273
2274                 [MonoTODO ("Does not use rowIndex parameter.")]
2275                 public void AutoResizeRowHeadersWidth (int rowIndex, DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode)
2276                 {
2277                         AutoResizeRowHeadersWidth (rowHeadersWidthSizeMode);
2278                 }
2279
2280                 public void AutoResizeRows ()
2281                 {
2282                         AutoResizeRows (0, Rows.Count, DataGridViewAutoSizeRowMode.AllCells, false);
2283                 }
2284
2285                 public void AutoResizeRows (DataGridViewAutoSizeRowsMode autoSizeRowsMode)
2286                 {
2287                         if (!Enum.IsDefined(typeof(DataGridViewAutoSizeRowsMode), autoSizeRowsMode))
2288                                 throw new InvalidEnumArgumentException ("Parameter autoSizeRowsMode is not a valid DataGridViewRowsMode.");
2289                         if ((autoSizeRowsMode == DataGridViewAutoSizeRowsMode.AllHeaders || autoSizeRowsMode == DataGridViewAutoSizeRowsMode.DisplayedHeaders) && rowHeadersVisible == false)
2290                                 throw new InvalidOperationException ("Parameter autoSizeRowsMode cannot be AllHeaders or DisplayedHeaders in this DataGridView.");
2291                         if (autoSizeRowsMode == DataGridViewAutoSizeRowsMode.None)
2292                                 throw new ArgumentException ("Parameter autoSizeRowsMode cannot be None.");
2293
2294                         AutoResizeRows (autoSizeRowsMode, false);
2295                 }
2296
2297                 public virtual bool BeginEdit (bool selectAll) {
2298                         if (currentCell == null || currentCell.IsInEditMode)
2299                                 return false;
2300
2301                         if (currentCell.RowIndex >= 0) {
2302                                 if ((currentCell.InheritedState & DataGridViewElementStates.ReadOnly) == DataGridViewElementStates.ReadOnly) {
2303                                         return false;
2304                                 }
2305                         }
2306
2307                         DataGridViewCell cell = currentCell;
2308                         Type editType = cell.EditType;
2309
2310                         if (editType == null && !(cell is IDataGridViewEditingCell))
2311                                 return false;
2312
2313                         // Give user a chance to cancel the edit
2314                         DataGridViewCellCancelEventArgs e = new DataGridViewCellCancelEventArgs (cell.ColumnIndex, cell.RowIndex);
2315                         OnCellBeginEdit (e);
2316
2317                         if (e.Cancel)
2318                                 return false;
2319
2320                         cell.SetIsInEditMode (true);
2321
2322                         // The cell has an editing control we need to setup
2323                         if (editType != null) {
2324                                 Control ctrl = EditingControlInternal;
2325
2326                                 // Check if we can reuse the one we already have
2327                                 bool isCorrectType = ctrl != null && ctrl.GetType () == editType;
2328
2329                                 if (!isCorrectType)
2330                                         ctrl = null;
2331
2332                                 // We couldn't use the existing one, create a new one
2333                                 if (ctrl == null) {
2334                                         ctrl = (Control) Activator.CreateInstance (editType);
2335                                         EditingControlInternal = ctrl;
2336                                 }
2337
2338                                 // Call some functions that allows the editing control to get setup
2339                                 DataGridViewCellStyle style = cell.RowIndex == -1 ? DefaultCellStyle : cell.InheritedStyle;
2340                                 cell.InitializeEditingControl (cell.RowIndex, cell.FormattedValue, style);
2341                                 OnEditingControlShowing (new DataGridViewEditingControlShowingEventArgs (EditingControlInternal, style));
2342                                 cell.PositionEditingControl (true, true, this.GetCellDisplayRectangle (cell.ColumnIndex, cell.RowIndex, false), bounds, style, false, false, (columns [cell.ColumnIndex].DisplayIndex == 0), (cell.RowIndex == 0));
2343
2344                                 // Show the editing control
2345                                 if (EditingControlInternal != null)
2346                                         EditingControlInternal.Visible = true;
2347
2348                                 IDataGridViewEditingControl dgvEditingControl = (IDataGridViewEditingControl) EditingControlInternal;
2349                                 if (dgvEditingControl != null) {
2350                                         dgvEditingControl.EditingControlDataGridView = this;
2351                                         dgvEditingControl.EditingControlRowIndex = currentCell.OwningRow.Index;
2352                                         dgvEditingControl.ApplyCellStyleToEditingControl (style);
2353                                         dgvEditingControl.PrepareEditingControlForEdit (selectAll);
2354                                         dgvEditingControl.EditingControlFormattedValue = currentCell.EditedFormattedValue;
2355                                 }
2356                                 return true;
2357                         }
2358
2359                         // If we are here, it means we have a cell that does not have an editing control
2360                         // and simply implements IDataGridViewEditingCell itself.
2361                         (cell as IDataGridViewEditingCell).PrepareEditingCellForEdit (selectAll);
2362
2363                         return true;
2364                 }
2365
2366                 public bool CancelEdit ()
2367                 {
2368                         if (currentCell != null) {
2369                                 if (currentCell.IsInEditMode) {
2370                                         currentCell.SetIsInEditMode (false);
2371                                         currentCell.DetachEditingControl ();
2372                                 }
2373
2374                                 if (currentCell.RowIndex == NewRowIndex) {
2375                                         if (DataManager != null)
2376                                                 DataManager.CancelCurrentEdit ();
2377
2378                                         new_row_editing = false;
2379                                         PrepareEditingRow (false, false);
2380                                         MoveCurrentCell (currentCell.ColumnIndex, NewRowIndex, true, false, false, true);
2381                                         OnUserDeletedRow (new DataGridViewRowEventArgs (EditingRow));
2382                                 }
2383                         }
2384
2385                         return true;
2386                 }
2387
2388                 public void ClearSelection ()
2389                 {
2390                         foreach (DataGridViewColumn col in SelectedColumns)
2391                                 col.Selected = false;
2392                         foreach (DataGridViewRow row in SelectedRows)
2393                                 row.Selected = false;
2394                         foreach (DataGridViewCell cell in SelectedCells)
2395                                 cell.Selected = false;
2396                 }
2397
2398                 public bool CommitEdit (DataGridViewDataErrorContexts context)
2399                 {
2400                         if (currentCell == null)
2401                                 return true;
2402
2403                         try {
2404                                 // convert
2405                                 object newValue = currentCell.ParseFormattedValue (currentCell.EditedFormattedValue,
2406                                                                                    currentCell.InheritedStyle, null, null);
2407
2408                                 DataGridViewCellValidatingEventArgs validateArgs = new DataGridViewCellValidatingEventArgs (currentCell.ColumnIndex,
2409                                                                                                                             currentCell.RowIndex,
2410                                                                                                                             newValue);
2411                                 // validate
2412                                 OnCellValidating (validateArgs);
2413                                 if (validateArgs.Cancel)
2414                                         return false;
2415                                 OnCellValidated (new DataGridViewCellEventArgs (currentCell.ColumnIndex, currentCell.RowIndex));
2416
2417                                 // commit
2418                                 currentCell.Value = newValue;
2419
2420                         } catch (Exception e) {
2421                                 DataGridViewDataErrorEventArgs args = new DataGridViewDataErrorEventArgs (e, currentCell.ColumnIndex, currentCell.RowIndex,
2422                                                                                                           DataGridViewDataErrorContexts.Commit);
2423                                 OnDataError (false, args);
2424                                 if (args.ThrowException)
2425                                         throw e;
2426                                 return false;
2427                         }
2428                         return true;
2429                 }
2430
2431                 public int DisplayedColumnCount (bool includePartialColumns)
2432                 {
2433                         int result = 0;
2434                         int columnLeft = 0;
2435
2436                         if (RowHeadersVisible)
2437                                 columnLeft += RowHeadersWidth;
2438
2439                         Size visibleClientArea = ClientSize;
2440                         if (verticalScrollBar.Visible)
2441                                 visibleClientArea.Width -= verticalScrollBar.Width;
2442                         if (horizontalScrollBar.Visible)
2443                                 visibleClientArea.Height -= horizontalScrollBar.Height;
2444
2445                         for (int index = first_col_index; index < Columns.Count; index++) {
2446                                 DataGridViewColumn column = Columns[ColumnDisplayIndexToIndex (index)];
2447                                 if (columnLeft + column.Width <= visibleClientArea.Width) {
2448                                         result++;
2449                                         columnLeft += column.Width;
2450                                 } else {
2451                                         if (includePartialColumns)
2452                                                 result++;
2453                                         break;
2454                                 }
2455                         }
2456
2457                         return result;
2458                 }
2459
2460                 public int DisplayedRowCount (bool includePartialRow)
2461                 {
2462                         int result = 0;
2463                         int rowTop = 0;
2464
2465                         if (ColumnHeadersVisible)
2466                                 rowTop += ColumnHeadersHeight;
2467
2468                         Size visibleClientArea = ClientSize;
2469                         if (verticalScrollBar.Visible)
2470                                 visibleClientArea.Width -= verticalScrollBar.Width;
2471                         if (horizontalScrollBar.Visible)
2472                                 visibleClientArea.Height -= horizontalScrollBar.Height;
2473
2474                         for (int index = first_row_index; index < Rows.Count; index++) {
2475                                 DataGridViewRow row = GetRowInternal (index);
2476                                 if (rowTop + row.Height <= visibleClientArea.Height) {
2477                                         result++;
2478                                         rowTop += row.Height;
2479                                 } else {
2480                                         if (includePartialRow)
2481                                                 result++;
2482                                         break;
2483                                 }
2484                         }
2485
2486                         return result;
2487                 }
2488
2489                 public bool EndEdit ()
2490                 {
2491                         return EndEdit (DataGridViewDataErrorContexts.Commit);
2492                 }
2493
2494                 [MonoTODO ("Does not use context parameter")]
2495                 public bool EndEdit (DataGridViewDataErrorContexts context)
2496                 {
2497                         if (currentCell == null || !currentCell.IsInEditMode)
2498                                 return true;
2499
2500                         if (!CommitEdit (context)) {
2501                                 if (DataManager != null)
2502                                         DataManager.EndCurrentEdit ();
2503                                 if (EditingControl != null)
2504                                         EditingControl.Focus ();
2505                                 return false;
2506                         }
2507
2508                         currentCell.SetIsInEditMode (false);
2509                         currentCell.DetachEditingControl ();
2510                         OnCellEndEdit (new DataGridViewCellEventArgs (currentCell.ColumnIndex, currentCell.RowIndex));
2511                         if (context != DataGridViewDataErrorContexts.LeaveControl)
2512                                 Focus ();
2513                         if (currentCell.RowIndex == NewRowIndex) {
2514                                 new_row_editing = false;
2515                                 editing_row = null; // editing row becomes a real row
2516                                 PrepareEditingRow (true, false); // add a new editing row
2517                                 MoveCurrentCell (currentCell.ColumnIndex, NewRowIndex, true, false, false, true);
2518                         }
2519                         return true;
2520                 }
2521
2522                 public int GetCellCount (DataGridViewElementStates includeFilter) {
2523                         int result = 0;
2524                         foreach (DataGridViewRow row in rows) {
2525                                 foreach (DataGridViewCell cell in row.Cells) {
2526                                         if ((cell.State & includeFilter) != 0) {
2527                                                 result++;
2528                                         }
2529                                 }
2530                         }
2531                         return result;
2532                 }
2533
2534                 internal DataGridViewRow GetRowInternal (int rowIndex)
2535                 {
2536                         return Rows.SharedRow (rowIndex);
2537                 }
2538
2539                 internal DataGridViewCell GetCellInternal (int colIndex, int rowIndex)
2540                 {
2541                         return GetRowInternal (rowIndex).Cells.GetCellInternal (colIndex);
2542                 }
2543
2544                 public Rectangle GetCellDisplayRectangle (int columnIndex, int rowIndex, bool cutOverflow) {
2545                         // Allow the column and row headers (index == -1).
2546                         if (columnIndex < -1 || columnIndex >= columns.Count) {
2547                                 throw new ArgumentOutOfRangeException ("Column index is out of range.");
2548                         }
2549                         if (rowIndex < -1 || (rowIndex > 0 && rowIndex >= rows.Count)) {
2550                                 throw new ArgumentOutOfRangeException ("Row index is out of range.");
2551                         }
2552
2553                         int x = 0, y = 0, w = 0, h = 0;
2554
2555                         x = BorderWidth;
2556                         y = BorderWidth;
2557
2558                         if (ColumnHeadersVisible)
2559                                 y += ColumnHeadersHeight;
2560
2561                         if (RowHeadersVisible)
2562                                 x += RowHeadersWidth;
2563
2564                         // Handle the top left cell when both column and row headers are showing.
2565                         if (columnIndex == -1 && rowIndex == -1)
2566                                 return new Rectangle (BorderWidth, BorderWidth, RowHeadersWidth, ColumnHeadersHeight);
2567
2568                         if (columnIndex >= 0)
2569                         {
2570                                 List<DataGridViewColumn> cols = columns.ColumnDisplayIndexSortedArrayList;
2571
2572                                 for (int i = first_col_index; i < cols.Count; i++) {
2573                                         if (!cols[i].Visible)
2574                                                 continue;
2575
2576                                         if (cols[i].Index == columnIndex) {
2577                                                 w = cols[i].Width;
2578                                                 break;
2579                                         }
2580
2581                                         x += cols[i].Width;
2582                                 }
2583                         }
2584
2585                         // Handle a cell in the header row.
2586                         if (rowIndex == -1)
2587                                 return new Rectangle (x, BorderWidth, w, ColumnHeadersHeight);
2588
2589                         for (int i = first_row_index; i < Rows.Count; i++) {
2590                                 if (!rows[i].Visible)
2591                                         continue;
2592
2593                                 if (rows[i].Index == rowIndex) {
2594                                         h = rows [i].Height;
2595                                         break;
2596                                 }
2597
2598                                 y += rows [i].Height;
2599                         }
2600
2601                         // Handle a cell in the header column.
2602                         if (columnIndex == -1)
2603                                 return new Rectangle (BorderWidth, y, RowHeadersWidth, h);
2604
2605                         return new Rectangle (x, y, w, h);
2606                 }
2607
2608                 public virtual DataObject GetClipboardContent () {
2609
2610                         if (clipboardCopyMode == DataGridViewClipboardCopyMode.Disable)
2611                                 throw new InvalidOperationException ("Generating Clipboard content is not supported when the ClipboardCopyMode property is Disable.");
2612
2613                         int start_row = int.MaxValue, end_row = int.MinValue;
2614                         int start_col = int.MaxValue, end_col = int.MinValue;
2615
2616                         bool include_row_headers = false;
2617                         bool include_col_headers = false;
2618                         bool only_included_headers = false;
2619                         bool headers_includable = false;
2620
2621                         switch (ClipboardCopyMode) {
2622                         case DataGridViewClipboardCopyMode.EnableWithoutHeaderText:
2623                                 break;
2624                         case DataGridViewClipboardCopyMode.EnableWithAutoHeaderText:
2625                                 // Headers are included if not selection mode is CellSelect, and any header is selected.
2626                                 headers_includable = selectionMode != DataGridViewSelectionMode.CellSelect;
2627                                 break;
2628                         case DataGridViewClipboardCopyMode.EnableAlwaysIncludeHeaderText:
2629                                 include_col_headers = include_row_headers = true;
2630                                 break;
2631                         }
2632
2633                         BitArray included_rows = new BitArray (RowCount);
2634                         BitArray included_cols = new BitArray (ColumnCount);
2635
2636                         // If there are any selected columns,
2637                         // include the column headers (if headers are to be shown).
2638                         if (headers_includable && !include_col_headers) {
2639                                 for (int c = 0; c < ColumnCount; c++) {
2640                                         if (Columns [c].Selected) {
2641                                                 include_col_headers = true;
2642                                                 break;
2643                                         }
2644                                 }
2645                         }
2646
2647                         // Find the smallest rectangle that encompasses all selected cells.
2648                         for (int r = 0; r < RowCount; r++) {
2649                                 DataGridViewRow row = Rows [r];
2650
2651                                 if (headers_includable && !include_row_headers && row.Selected) {
2652                                         include_row_headers = true;
2653                                 }
2654
2655                                 for (int c = 0; c < ColumnCount; c++) {
2656                                         DataGridViewCell cell = row.Cells [c];
2657
2658                                         if (cell == null || !cell.Selected)
2659                                                 continue;
2660
2661                                         included_cols [c] = true;
2662                                         included_rows [r] = true;
2663
2664                                         start_row = Math.Min (start_row, r);
2665                                         start_col = Math.Min (start_col, c);
2666                                         end_row = Math.Max (end_row, r);
2667                                         end_col = Math.Max (end_col, c);
2668                                 }
2669                         }
2670
2671                         // Mark rows/columns in between selected cells as included if the selection mode isn't FullHeaderSelect.
2672                         switch (selectionMode){
2673                         case DataGridViewSelectionMode.CellSelect:
2674                         case DataGridViewSelectionMode.ColumnHeaderSelect:
2675                         case DataGridViewSelectionMode.RowHeaderSelect:
2676                                 if (selectionMode != DataGridViewSelectionMode.ColumnHeaderSelect) {
2677                                         for (int r = start_row; r <= end_row; r++) {
2678                                                 included_rows.Set (r, true);
2679                                         }
2680                                 } else if (start_row <= end_row) {
2681                                         included_rows.SetAll (true);
2682                                 }
2683                                 if (selectionMode != DataGridViewSelectionMode.RowHeaderSelect) {
2684                                         for (int c = start_col; c <= end_col; c++) {
2685                                                 included_cols.Set (c, true);
2686                                         }
2687                                 }
2688                                 break;
2689                         case DataGridViewSelectionMode.FullColumnSelect:
2690                         case DataGridViewSelectionMode.FullRowSelect:
2691                                 only_included_headers = true;
2692                                 break;
2693                         }
2694
2695                         if (start_row > end_row)
2696                                 return null;
2697
2698                         if (start_col > end_col)
2699                                 return null;
2700
2701                         DataObject result = new DataObject ();
2702
2703                         StringBuilder text_builder = new StringBuilder ();
2704                         StringBuilder utext_builder = new StringBuilder ();
2705                         StringBuilder html_builder = new StringBuilder ();
2706                         StringBuilder csv_builder = new StringBuilder ();
2707
2708                         // Loop through all rows and columns to create the content.
2709                         // -1 is the header row/column.
2710                         int first_row = start_row;
2711                         int first_col = start_col;
2712                         if (include_col_headers) {
2713                                 first_row = -1;
2714                         }
2715                         for (int r = first_row; r <= end_row; r++) {
2716                                 DataGridViewRow row = null;
2717
2718                                 if (r >= 0) {
2719                                         if (!included_rows [r])
2720                                                 continue;
2721
2722                                         row = Rows [r];
2723                                 }
2724
2725                                 if (include_row_headers) {
2726                                         first_col = -1;
2727                                 }
2728
2729                                 for (int c = first_col; c <= end_col; c++) {
2730                                         DataGridViewCell cell = null;
2731
2732                                         if (c >= 0 && only_included_headers && !included_cols [c])
2733                                                 continue;
2734
2735                                         if (row == null) {
2736                                                 if (c == -1) {
2737                                                         cell = TopLeftHeaderCell;
2738                                                 } else {
2739                                                         cell = Columns [c].HeaderCell;
2740                                                 }
2741                                         } else {
2742                                                 if (c == -1) {
2743                                                         cell = row.HeaderCell;
2744                                                 } else {
2745                                                         cell = row.Cells [c];
2746                                                 }
2747                                         }
2748
2749                                         string text, utext, html, csv;
2750                                         bool is_first_cell = (c == first_col);
2751                                         bool is_last_cell = (c == end_col);
2752                                         bool is_first_row = (r == first_row);
2753                                         bool is_last_row = (r == end_row);
2754
2755                                         if (cell == null) {
2756                                                 text = string.Empty;
2757                                                 utext = string.Empty;
2758                                                 html = string.Empty;
2759                                                 csv = string.Empty;
2760                                         } else {
2761                                                 text = cell.GetClipboardContentInternal (r, is_first_cell, is_last_cell, is_first_row, is_last_row, DataFormats.Text) as string;
2762                                                 utext = cell.GetClipboardContentInternal (r, is_first_cell, is_last_cell, is_first_row, is_last_row, DataFormats.UnicodeText) as string;
2763                                                 html = cell.GetClipboardContentInternal (r, is_first_cell, is_last_cell, is_first_row, is_last_row, DataFormats.Html) as string;
2764                                                 csv = cell.GetClipboardContentInternal (r, is_first_cell, is_last_cell, is_first_row, is_last_row, DataFormats.CommaSeparatedValue) as string;
2765                                         }
2766
2767                                         text_builder.Append (text);
2768                                         utext_builder.Append (utext);
2769                                         html_builder.Append (html);
2770                                         csv_builder.Append (csv);
2771
2772                                         if (c == -1) { // If we just did the row header, jump to the first column.
2773                                                 c = start_col - 1;
2774                                         }
2775                                 }
2776
2777                                 if (r == -1) {// If we just did the column header, jump to the first row.
2778                                         r = start_row - 1;
2779                                 }
2780                         }
2781
2782                         //
2783                         // Html content always get the \r\n newline
2784                         // It's valid html anyway, and it eases testing quite a bit
2785                         // (since otherwise we'd have to change the start indices
2786                         // in the added prologue/epilogue text)
2787                         //
2788                         int fragment_end = 135 + html_builder.Length;
2789                         int html_end = fragment_end + 36;
2790                         string html_start =
2791                         "Version:1.0{0}" +
2792                         "StartHTML:00000097{0}" +
2793                         "EndHTML:{1:00000000}{0}" +
2794                         "StartFragment:00000133{0}" +
2795                         "EndFragment:{2:00000000}{0}" +
2796                         "<HTML>{0}" +
2797                         "<BODY>{0}" +
2798                         "<!--StartFragment-->";
2799
2800                         html_start = string.Format (html_start, "\r\n", html_end, fragment_end);
2801                         html_builder.Insert (0, html_start);
2802                         html_builder.AppendFormat ("{0}<!--EndFragment-->{0}</BODY>{0}</HTML>", "\r\n");
2803
2804                         result.SetData (DataFormats.CommaSeparatedValue, false, csv_builder.ToString ());
2805                         result.SetData (DataFormats.Html, false, html_builder.ToString ());
2806                         result.SetData (DataFormats.UnicodeText, false, utext_builder.ToString ());
2807                         result.SetData (DataFormats.Text, false, text_builder.ToString ());
2808
2809                         return result;
2810                 }
2811
2812                 [MonoTODO ("Does not use cutOverflow parameter")]
2813                 public Rectangle GetColumnDisplayRectangle (int columnIndex, bool cutOverflow)
2814                 {
2815                         if (columnIndex < 0 || columnIndex > Columns.Count - 1)
2816                                 throw new ArgumentOutOfRangeException ("columnIndex");
2817
2818                         int x = 0;
2819                         int w = 0;
2820
2821                         x = BorderWidth;
2822
2823                         if (RowHeadersVisible)
2824                                 x += RowHeadersWidth;
2825
2826                         List<DataGridViewColumn> cols = columns.ColumnDisplayIndexSortedArrayList;
2827
2828                         for (int i = first_col_index; i < cols.Count; i++) {
2829                                 if (!cols[i].Visible)
2830                                         continue;
2831
2832                                 if (cols[i].Index == columnIndex) {
2833                                         w = cols[i].Width;
2834                                         break;
2835                                 }
2836
2837                                 x += cols[i].Width;
2838                         }
2839
2840                         return new Rectangle (x, 0, w, Height);
2841                 }
2842
2843                 [MonoTODO ("Does not use cutOverflow parameter")]
2844                 public Rectangle GetRowDisplayRectangle (int rowIndex, bool cutOverflow)
2845                 {
2846                         if (rowIndex < 0 || rowIndex > Rows.Count - 1)
2847                                 throw new ArgumentOutOfRangeException ("rowIndex");
2848
2849                         int y = 0;
2850                         int h = 0;
2851
2852                         y = BorderWidth;
2853
2854                         if (ColumnHeadersVisible)
2855                                 y += ColumnHeadersHeight;
2856
2857
2858                         for (int i = first_row_index; i < Rows.Count; i++) {
2859                                 if (!rows[i].Visible)
2860                                         continue;
2861
2862                                 if (rows[i].Index == rowIndex) {
2863                                         h = rows [i].Height;
2864                                         break;
2865                                 }
2866
2867                                 y += rows [i].Height;
2868                         }
2869
2870                         return new Rectangle (0, y, Width, h);
2871                 }
2872
2873                 public HitTestInfo HitTest (int x, int y) {
2874                         ///////////////////////////////////////////////////////
2875                         //Console.WriteLine ("HitTest ({0}, {1})", x, y);
2876                         bool isInColHeader = columnHeadersVisible && y >= 0 && y <= ColumnHeadersHeight;
2877                         bool isInRowHeader = rowHeadersVisible && x >= 0 && x <= RowHeadersWidth;
2878
2879                         // TopLeftHeader
2880                         if (isInColHeader && isInRowHeader)
2881                                 return new HitTestInfo (-1, x, -1, y, DataGridViewHitTestType.TopLeftHeader);
2882
2883                         // HorizontalScrollBar
2884                         if (horizontalScrollBar.Visible && horizontalScrollBar.Bounds.Contains (x, y))
2885                                 return new HitTestInfo (-1, x, -1, y, DataGridViewHitTestType.HorizontalScrollBar);
2886
2887                         // VerticalScrollBar
2888                         if (verticalScrollBar.Visible && verticalScrollBar.Bounds.Contains (x, y))
2889                                 return new HitTestInfo (-1, x, -1, y, DataGridViewHitTestType.VerticalScrollBar);
2890
2891                         // The little box in the bottom right if both scrollbars are shown is None
2892                         if (verticalScrollBar.Visible && horizontalScrollBar.Visible)
2893                                 if (new Rectangle (verticalScrollBar.Left, horizontalScrollBar.Top, verticalScrollBar.Width, horizontalScrollBar.Height).Contains (x, y))
2894                                         return new HitTestInfo (-1, x, -1, y, DataGridViewHitTestType.None);
2895
2896                         int rowindex = -1;
2897                         int colindex = -1;
2898
2899                         int top = columnHeadersVisible ? columnHeadersHeight : 0;
2900
2901                         for (int i = first_row_index; i < Rows.Count; i++) {
2902                                 DataGridViewRow row = Rows[i];
2903                                 if (!row.Visible)
2904                                         continue;
2905
2906                                 if (y > top && y <= (top + row.Height)) {
2907                                         rowindex = i;
2908                                         break;
2909                                 }
2910
2911                                 top += row.Height;
2912                         }
2913
2914                         int left = rowHeadersVisible ? RowHeadersWidth : 0;
2915
2916                         List<DataGridViewColumn> cols = columns.ColumnDisplayIndexSortedArrayList;
2917
2918                         for (int i = first_col_index; i < cols.Count; i++) {
2919                                 if (!cols[i].Visible)
2920                                         continue;
2921
2922                                 if (x > left && x <= (left + cols[i].Width)) {
2923                                         colindex = cols[i].Index;
2924                                         break;
2925                                 }
2926
2927                                 left += cols[i].Width;
2928                         }
2929
2930                         if (colindex >= 0 && rowindex >= 0)
2931                                 return new HitTestInfo (colindex, x, rowindex, y, DataGridViewHitTestType.Cell);
2932
2933                         if (isInColHeader && colindex > -1)
2934                                 return new HitTestInfo (colindex, x, rowindex, y, DataGridViewHitTestType.ColumnHeader);
2935
2936                         if (isInRowHeader && rowindex > -1)
2937                                 return new HitTestInfo (colindex, x, rowindex, y, DataGridViewHitTestType.RowHeader);
2938
2939                         return new HitTestInfo (-1, x, -1, y, DataGridViewHitTestType.None);
2940                 }
2941
2942                 public void InvalidateCell (DataGridViewCell dataGridViewCell)
2943                 {
2944                         if (dataGridViewCell == null)
2945                                 throw new ArgumentNullException ("Cell is null");
2946
2947                         if (dataGridViewCell.DataGridView != this)
2948                                 throw new ArgumentException ("The specified cell does not belong to this DataGridView.");
2949
2950                         InvalidateCell (dataGridViewCell.ColumnIndex, dataGridViewCell.RowIndex);
2951                 }
2952
2953                 public void InvalidateCell (int columnIndex, int rowIndex)
2954                 {
2955                         // Allow the header column (columnIndex == -1).
2956                         if (columnIndex < -1 || columnIndex >= columns.Count)
2957                                 throw new ArgumentOutOfRangeException ("Column index is out of range.");
2958
2959                         // Allow the header row (rowIndex == -1).
2960                         if (rowIndex < -1 || rowIndex >= rows.Count)
2961                                 throw new ArgumentOutOfRangeException ("Row index is out of range.");
2962
2963                         if (!is_binding)
2964                                 Invalidate (GetCellDisplayRectangle (columnIndex, rowIndex, true));
2965                 }
2966
2967                 public void InvalidateColumn (int columnIndex)
2968                 {
2969                         if (columnIndex < 0 || columnIndex >= columns.Count)
2970                                 throw new ArgumentOutOfRangeException ("Column index is out of range.");
2971
2972                         if (!is_binding)
2973                                 Invalidate (GetColumnDisplayRectangle (columnIndex, true));
2974                 }
2975
2976                 public void InvalidateRow (int rowIndex)
2977                 {
2978                         if (rowIndex < 0 || rowIndex >= rows.Count)
2979                                 throw new ArgumentOutOfRangeException ("Row index is out of range.");
2980
2981                         if (!is_binding)
2982                                 Invalidate (GetRowDisplayRectangle (rowIndex, true));
2983                 }
2984
2985                 public virtual void NotifyCurrentCellDirty (bool dirty) {
2986                         if (currentCell != null)
2987                                 InvalidateCell (currentCell);
2988                 }
2989
2990                 public bool RefreshEdit ()
2991                 {
2992                         if (IsCurrentCellInEditMode) {
2993                                 currentCell.InitializeEditingControl (currentCell.RowIndex, currentCell.FormattedValue, currentCell.InheritedStyle);
2994                                 return true;
2995                         }
2996
2997                         return false;
2998                 }
2999
3000                 [EditorBrowsable (EditorBrowsableState.Never)]
3001                 public override void ResetText ()
3002                 {
3003                         Text = string.Empty;
3004                 }
3005
3006                 public void SelectAll () {
3007                         switch (selectionMode) {
3008                                 case DataGridViewSelectionMode.FullRowSelect:
3009                                         foreach (DataGridViewRow row in rows) {
3010                                                 (row as DataGridViewBand).Selected = true;
3011                                         }
3012                                         break;
3013                                 case DataGridViewSelectionMode.FullColumnSelect:
3014                                         foreach (DataGridViewColumn col in columns) {
3015                                                 (col as DataGridViewBand).Selected = true;
3016                                         }
3017                                         break;
3018                                 default:
3019                                         foreach (DataGridViewRow row in rows) {
3020                                                 foreach (DataGridViewCell cell in row.Cells) {
3021                                                         cell.Selected = true;
3022                                                 }
3023                                         }
3024                                         break;
3025                         }
3026
3027                         Invalidate ();
3028                 }
3029
3030                 public virtual void Sort (IComparer comparer)
3031                 {
3032                         if (comparer == null)
3033                                 throw new ArgumentNullException ("comparer");
3034                         if (VirtualMode || DataSource != null)
3035                                 throw new InvalidOperationException ();
3036
3037                         if (SortedColumn != null)
3038                                 SortedColumn.HeaderCell.SortGlyphDirection = SortOrder.None;
3039
3040                         EndEdit ();
3041
3042                         Rows.Sort (comparer);
3043
3044                         sortedColumn = null;
3045                         sortOrder = SortOrder.None;
3046
3047                         currentCell = null;
3048
3049                         Invalidate ();
3050
3051                         OnSorted (EventArgs.Empty);
3052                 }
3053
3054                 public virtual void Sort (DataGridViewColumn dataGridViewColumn, ListSortDirection direction)
3055                 {
3056                         if (dataGridViewColumn == null)
3057                                 throw new ArgumentNullException ("dataGridViewColumn");
3058                         if (dataGridViewColumn.DataGridView != this)
3059                                 throw new ArgumentException ("dataGridViewColumn");
3060
3061                         if (!EndEdit ())
3062                                 return;
3063
3064                         if (SortedColumn != null)
3065                                 SortedColumn.HeaderCell.SortGlyphDirection = SortOrder.None;
3066
3067                         sortedColumn = dataGridViewColumn;
3068                         sortOrder = direction == ListSortDirection.Ascending ? SortOrder.Ascending : SortOrder.Descending;
3069
3070                         if (Rows.Count == 0)
3071                                 return;
3072
3073                         if (dataGridViewColumn.IsDataBound) {
3074                                 IBindingList bindingList = DataManager.List as IBindingList;
3075                                 if (bindingList != null && bindingList.SupportsSorting) {
3076                                         bindingList.ApplySort (DataManager.GetItemProperties()[dataGridViewColumn.DataPropertyName], direction);
3077                                         dataGridViewColumn.HeaderCell.SortGlyphDirection = sortOrder;
3078                                 }
3079                         } else {
3080                                 // Figure out if this is a numeric sort or text sort
3081                                 bool is_numeric = true;
3082                                 double n;
3083
3084                                 foreach (DataGridViewRow row in Rows) {
3085                                         object val = row.Cells[dataGridViewColumn.Index].Value;
3086
3087                                         if (val != null && !double.TryParse (val.ToString (), out n)) {
3088                                                 is_numeric = false;
3089                                                 break;
3090                                         }
3091                                 }
3092
3093                                 ColumnSorter sorter = new ColumnSorter (dataGridViewColumn, direction, is_numeric);
3094                                 Rows.Sort (sorter);
3095                                 dataGridViewColumn.HeaderCell.SortGlyphDirection = sortOrder;
3096                         }
3097
3098                         Invalidate ();
3099                         OnSorted (EventArgs.Empty);
3100                 }
3101
3102                 public void UpdateCellErrorText (int columnIndex, int rowIndex)
3103                 {
3104                         if (columnIndex < 0 || columnIndex > Columns.Count - 1)
3105                                 throw new ArgumentOutOfRangeException ("columnIndex");
3106                         if (rowIndex < 0 || rowIndex > Rows.Count - 1)
3107                                 throw new ArgumentOutOfRangeException ("rowIndex");
3108
3109                         InvalidateCell (columnIndex, rowIndex);
3110                 }
3111
3112                 public void UpdateCellValue (int columnIndex, int rowIndex)
3113                 {
3114                         if (columnIndex < 0 || columnIndex > Columns.Count - 1)
3115                                 throw new ArgumentOutOfRangeException ("columnIndex");
3116                         if (rowIndex < 0 || rowIndex > Rows.Count - 1)
3117                                 throw new ArgumentOutOfRangeException ("rowIndex");
3118
3119                         InvalidateCell (columnIndex, rowIndex);
3120                 }
3121
3122                 public void UpdateRowErrorText (int rowIndex)
3123                 {
3124                         if (rowIndex < 0 || rowIndex > Rows.Count - 1)
3125                                 throw new ArgumentOutOfRangeException ("rowIndex");
3126
3127                         InvalidateRow (rowIndex);
3128                 }
3129
3130                 public void UpdateRowErrorText (int rowIndexStart, int rowIndexEnd)
3131                 {
3132                         if (rowIndexStart < 0 || rowIndexStart > Rows.Count - 1)
3133                                 throw new ArgumentOutOfRangeException ("rowIndexStart");
3134                         if (rowIndexEnd < 0 || rowIndexEnd > Rows.Count - 1)
3135                                 throw new ArgumentOutOfRangeException ("rowIndexEnd");
3136                         if (rowIndexEnd < rowIndexStart)
3137                                 throw new ArgumentOutOfRangeException ("rowIndexEnd", "rowIndexEnd must be greater than rowIndexStart");
3138
3139                         for (int i = rowIndexStart; i <= rowIndexEnd; i++)
3140                                 InvalidateRow (i);
3141                 }
3142
3143                 public void UpdateRowHeightInfo (int rowIndex, bool updateToEnd)
3144                 {
3145                         if (rowIndex < 0 && updateToEnd)
3146                                 throw new ArgumentOutOfRangeException ("rowIndex");
3147                         if (rowIndex < -1 && !updateToEnd)
3148                                 throw new ArgumentOutOfRangeException ("rowIndex");
3149                         if (rowIndex >= Rows.Count)
3150                                 throw new ArgumentOutOfRangeException ("rowIndex");
3151
3152                         if (!VirtualMode && DataManager == null)
3153                                 return;
3154
3155                         if (rowIndex == -1) {
3156                                 updateToEnd = true;
3157                                 rowIndex = 0;
3158                         }
3159
3160                         if (updateToEnd) {
3161                                 for (int i = rowIndex; i < Rows.Count; i++) {
3162                                         DataGridViewRow row = Rows[i];
3163                                         if (!row.Visible)
3164                                                 continue;
3165
3166                                         DataGridViewRowHeightInfoNeededEventArgs rowInfo =
3167                                                 new DataGridViewRowHeightInfoNeededEventArgs (row.Index, row.Height, row.MinimumHeight);
3168                                         OnRowHeightInfoNeeded (rowInfo);
3169
3170                                         if (row.Height != rowInfo.Height || row.MinimumHeight != rowInfo.MinimumHeight) {
3171                                                 row.Height = rowInfo.Height;
3172                                                 row.MinimumHeight = rowInfo.MinimumHeight;
3173                                                 OnRowHeightInfoPushed (new DataGridViewRowHeightInfoPushedEventArgs (row.Index, rowInfo.Height,
3174                                                                                                                      rowInfo.MinimumHeight));
3175                                         }
3176                                 }
3177                         } else {
3178                                 DataGridViewRow row = Rows[rowIndex];
3179                                 DataGridViewRowHeightInfoNeededEventArgs rowInfo =
3180                                         new DataGridViewRowHeightInfoNeededEventArgs (row.Index, row.Height, row.MinimumHeight);
3181                                 OnRowHeightInfoNeeded (rowInfo);
3182
3183                                 if (row.Height != rowInfo.Height || row.MinimumHeight != rowInfo.MinimumHeight) {
3184                                         row.Height = rowInfo.Height;
3185                                         row.MinimumHeight = rowInfo.MinimumHeight;
3186                                         OnRowHeightInfoPushed (new DataGridViewRowHeightInfoPushedEventArgs (row.Index, rowInfo.Height,
3187                                                                                                              rowInfo.MinimumHeight));
3188                                 }
3189                         }
3190                 }
3191
3192                 protected override bool CanEnableIme {
3193                         get {
3194                                 if (CurrentCell != null && CurrentCell.EditType != null)
3195                                         return true;
3196
3197                                 return false;
3198                         }
3199                 }
3200
3201                 protected override Size DefaultSize {
3202                         get { return new Size (240, 150); }
3203                 }
3204
3205                 protected ScrollBar HorizontalScrollBar {
3206                         get { return horizontalScrollBar; }
3207                 }
3208
3209                 protected ScrollBar VerticalScrollBar {
3210                         get { return verticalScrollBar; }
3211                 }
3212
3213                 protected virtual void AccessibilityNotifyCurrentCellChanged (Point cellAddress)
3214                 {
3215                         throw new NotImplementedException ();
3216                 }
3217
3218                 [MonoTODO ("Does not use fixedHeight parameter")]
3219                 protected void AutoResizeColumn (int columnIndex, DataGridViewAutoSizeColumnMode autoSizeColumnMode, bool fixedHeight)
3220                 {
3221                         AutoResizeColumn (columnIndex, autoSizeColumnMode);
3222                 }
3223
3224                 [MonoTODO ("Does not use fixedRowHeadersWidth or fixedColumnsWidth parameters")]
3225                 protected void AutoResizeColumnHeadersHeight (bool fixedRowHeadersWidth, bool fixedColumnsWidth)
3226                 {
3227                         AutoResizeColumnHeadersHeight ();
3228                 }
3229
3230                 [MonoTODO ("Does not use columnIndex or fixedRowHeadersWidth or fixedColumnsWidth parameters")]
3231                 protected void AutoResizeColumnHeadersHeight (int columnIndex, bool fixedRowHeadersWidth, bool fixedColumnWidth)
3232                 {
3233                         AutoResizeColumnHeadersHeight (columnIndex);
3234                 }
3235
3236                 protected void AutoResizeColumns (DataGridViewAutoSizeColumnsMode autoSizeColumnsMode, bool fixedHeight) {
3237                         for (int i = 0; i < Columns.Count; i++) {
3238                                 AutoResizeColumn (i, (DataGridViewAutoSizeColumnMode) autoSizeColumnsMode, fixedHeight);
3239                         }
3240                 }
3241
3242                 [MonoTODO ("Does not use fixedWidth parameter")]
3243                 protected void AutoResizeRow (int rowIndex, DataGridViewAutoSizeRowMode autoSizeRowMode, bool fixedWidth)
3244                 {
3245                         if (autoSizeRowMode == DataGridViewAutoSizeRowMode.RowHeader && !rowHeadersVisible)
3246                                 throw new InvalidOperationException ("row headers are not visible");
3247                         if (rowIndex < 0 || rowIndex > Rows.Count - 1)
3248                                 throw new ArgumentOutOfRangeException ("rowIndex");
3249
3250                         DataGridViewRow row = GetRowInternal (rowIndex);
3251
3252                         int new_height = row.GetPreferredHeight (rowIndex, autoSizeRowMode, true);
3253
3254                         if (row.Height != new_height)
3255                                 row.SetAutoSizeHeight (new_height);
3256                 }
3257
3258                 [MonoTODO ("Does not use fixedColumnHeadersHeight or fixedRowsHeight parameter")]
3259                 protected void AutoResizeRowHeadersWidth (DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode, bool fixedColumnHeadersHeight, bool fixedRowsHeight)
3260                 {
3261                         AutoResizeRowHeadersWidth (rowHeadersWidthSizeMode);
3262                 }
3263
3264                 [MonoTODO ("Does not use rowIndex or fixedColumnHeadersHeight or fixedRowsHeight parameter")]
3265                 protected void AutoResizeRowHeadersWidth (int rowIndex, DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode, bool fixedColumnHeadersHeight, bool fixedRowHeight)
3266                 {
3267                         AutoResizeRowHeadersWidth (rowHeadersWidthSizeMode);
3268                 }
3269
3270                 [MonoTODO ("Does not use fixedWidth parameter")]
3271                 protected void AutoResizeRows (DataGridViewAutoSizeRowsMode autoSizeRowsMode, bool fixedWidth)
3272                 {
3273                         if (autoSizeRowsMode == DataGridViewAutoSizeRowsMode.None)
3274                                 return;
3275
3276                         bool displayed_only = false;
3277                         DataGridViewAutoSizeRowMode mode = DataGridViewAutoSizeRowMode.AllCells;
3278
3279                         switch (autoSizeRowsMode) {
3280                                 case DataGridViewAutoSizeRowsMode.AllHeaders:
3281                                         mode = DataGridViewAutoSizeRowMode.RowHeader;
3282                                         break;
3283                                 case DataGridViewAutoSizeRowsMode.AllCellsExceptHeaders:
3284                                         mode = DataGridViewAutoSizeRowMode.AllCellsExceptHeader;
3285                                         break;
3286                                 case DataGridViewAutoSizeRowsMode.AllCells:
3287                                         mode = DataGridViewAutoSizeRowMode.AllCells;
3288                                         break;
3289                                 case DataGridViewAutoSizeRowsMode.DisplayedHeaders:
3290                                         mode = DataGridViewAutoSizeRowMode.RowHeader;
3291                                         displayed_only = true;
3292                                         break;
3293                                 case DataGridViewAutoSizeRowsMode.DisplayedCellsExceptHeaders:
3294                                         mode = DataGridViewAutoSizeRowMode.AllCellsExceptHeader;
3295                                         displayed_only = true;
3296                                         break;
3297                                 case DataGridViewAutoSizeRowsMode.DisplayedCells:
3298                                         mode = DataGridViewAutoSizeRowMode.AllCells;
3299                                         displayed_only = true;
3300                                         break;
3301                         }
3302
3303                         foreach (DataGridViewRow row in Rows) {
3304                                 if (!row.Visible)
3305                                         continue;
3306                                 if (!displayed_only || row.Displayed) {
3307                                         int new_height = row.GetPreferredHeight (row.Index, mode, fixedWidth);
3308
3309                                         if (row.Height != new_height)
3310                                                 row.SetAutoSizeHeight (new_height);
3311                                 }
3312                         }
3313                 }
3314
3315                 [MonoTODO ("Does not use fixedMode parameter")]
3316                 protected void AutoResizeRows (int rowIndexStart, int rowsCount, DataGridViewAutoSizeRowMode autoSizeRowMode, bool fixedWidth)
3317                 {
3318                         for (int i = rowIndexStart; i < rowIndexStart + rowsCount; i++)
3319                                 AutoResizeRow (i, autoSizeRowMode, fixedWidth);
3320                 }
3321
3322                 protected void ClearSelection (int columnIndexException, int rowIndexException, bool selectExceptionElement) {
3323                         if (columnIndexException >= columns.Count) {
3324                                 throw new ArgumentOutOfRangeException("ColumnIndexException is greater than the highest column index.");
3325                         }
3326                         if (selectionMode == DataGridViewSelectionMode.FullRowSelect) {
3327                                 if (columnIndexException < -1) {
3328                                         throw new ArgumentOutOfRangeException("ColumnIndexException is less than -1.");
3329                                 }
3330                         }
3331                         else {
3332                                 if (columnIndexException < 0) {
3333                                         throw new ArgumentOutOfRangeException("ColumnIndexException is less than 0.");
3334                                 }
3335                         }
3336                         if (rowIndexException >= rows.Count) {
3337                                 throw new ArgumentOutOfRangeException("RowIndexException is greater than the highest row index.");
3338                         }
3339                         if (selectionMode == DataGridViewSelectionMode.FullColumnSelect) {
3340                                 if (rowIndexException < -1) {
3341                                         throw new ArgumentOutOfRangeException("RowIndexException is less than -1.");
3342                                 }
3343                         }
3344                         else {
3345                                 if (rowIndexException < 0) {
3346                                         throw new ArgumentOutOfRangeException("RowIndexException is less than 0.");
3347                                 }
3348                         }
3349                         switch (selectionMode) {
3350                                 case DataGridViewSelectionMode.FullRowSelect:
3351                                         foreach (DataGridViewRow row in rows) {
3352                                                 if (selectExceptionElement && row.Index == rowIndexException) {
3353                                                         continue;
3354                                                 }
3355                                                 SetSelectedRowCore (row.Index, false);
3356                                         }
3357                                         break;
3358                                 case DataGridViewSelectionMode.FullColumnSelect:
3359                                         foreach (DataGridViewColumn col in columns) {
3360                                                 if (selectExceptionElement && col.Index == columnIndexException) {
3361                                                         continue;
3362                                                 }
3363                                                 SetSelectedColumnCore (col.Index, false);
3364                                         }
3365                                         break;
3366                                 default:
3367                                         foreach (DataGridViewCell cell in SelectedCells) {
3368                                                 if (selectExceptionElement && cell.RowIndex == rowIndexException && cell.ColumnIndex == columnIndexException) {
3369                                                         continue;
3370                                                 }
3371                                                 SetSelectedCellCore (cell.ColumnIndex, cell.RowIndex, false);
3372                                         }
3373                                         break;
3374                         }
3375                 }
3376
3377                 protected override AccessibleObject CreateAccessibilityInstance ()
3378                 {
3379                         return new DataGridViewAccessibleObject(this);
3380                 }
3381
3382                 [EditorBrowsable (EditorBrowsableState.Advanced)]
3383                 protected virtual DataGridViewColumnCollection CreateColumnsInstance ()
3384                 {
3385                         return new DataGridViewColumnCollection(this);
3386                 }
3387
3388                 protected override Control.ControlCollection CreateControlsInstance ()
3389                 {
3390                         return new DataGridViewControlCollection (this);
3391                 }
3392
3393                 [EditorBrowsable (EditorBrowsableState.Advanced)]
3394                 protected virtual DataGridViewRowCollection CreateRowsInstance ()
3395                 {
3396                         return new DataGridViewRowCollection(this);
3397                 }
3398
3399                 protected override void Dispose (bool disposing) {
3400                         if (disposing) {
3401                                 ClearSelection();
3402                                 currentCell = null;
3403                                 foreach (DataGridViewColumn column in Columns)
3404                                         column.Dispose();
3405                                 Columns.Clear();
3406                                 foreach (DataGridViewRow row in Rows)
3407                                         row.Dispose();
3408                                 Rows.Clear();
3409                         }
3410                         editingControl = null;
3411
3412                         base.Dispose(disposing);
3413                 }
3414
3415                 protected override AccessibleObject GetAccessibilityObjectById (int objectId)
3416                 {
3417                         throw new NotImplementedException();
3418                 }
3419
3420                 protected override bool IsInputChar (char charCode)
3421                 {
3422                         return true;
3423                 }
3424
3425                 protected override bool IsInputKey (Keys keyData)
3426                 {
3427                         // Don't look at the modifiers
3428                         keyData = keyData & ~Keys.Modifiers;
3429
3430                         switch (keyData) {
3431                                 case Keys.Return:
3432                                 case Keys.PageUp:
3433                                 case Keys.Next:
3434                                 case Keys.End:
3435                                 case Keys.Home:
3436                                 case Keys.Left:
3437                                 case Keys.Up:
3438                                 case Keys.Right:
3439                                 case Keys.Down:
3440                                 case Keys.Delete:
3441                                 case Keys.D0:
3442                                 case Keys.NumPad0:
3443                                 case Keys.F2:
3444                                         return true;
3445                         }
3446
3447                         return false;
3448                 }
3449
3450                 protected virtual void OnAllowUserToAddRowsChanged (EventArgs e)
3451                 {
3452                         EventHandler eh = (EventHandler)(Events [AllowUserToAddRowsChangedEvent]);
3453                         if (eh != null)
3454                                 eh (this, e);
3455                 }
3456
3457                 protected virtual void OnAllowUserToDeleteRowsChanged (EventArgs e)
3458                 {
3459                         EventHandler eh = (EventHandler)(Events [AllowUserToDeleteRowsChangedEvent]);
3460                         if (eh != null)
3461                                 eh (this, e);
3462                 }
3463
3464                 protected virtual void OnAllowUserToOrderColumnsChanged (EventArgs e)
3465                 {
3466                         EventHandler eh = (EventHandler)(Events [AllowUserToOrderColumnsChangedEvent]);
3467                         if (eh != null)
3468                                 eh (this, e);
3469                 }
3470
3471                 protected virtual void OnAllowUserToResizeColumnsChanged (EventArgs e)
3472                 {
3473                         EventHandler eh = (EventHandler)(Events [AllowUserToResizeColumnsChangedEvent]);
3474                         if (eh != null)
3475                                 eh (this, e);
3476                 }
3477
3478                 protected virtual void OnAllowUserToResizeRowsChanged (EventArgs e)
3479                 {
3480                         EventHandler eh = (EventHandler)(Events [AllowUserToResizeRowsChangedEvent]);
3481                         if (eh != null)
3482                                 eh (this, e);
3483                 }
3484
3485                 protected virtual void OnAlternatingRowsDefaultCellStyleChanged (EventArgs e)
3486                 {
3487                         EventHandler eh = (EventHandler)(Events [AlternatingRowsDefaultCellStyleChangedEvent]);
3488                         if (eh != null)
3489                                 eh (this, e);
3490                 }
3491
3492                 protected virtual void OnAutoGenerateColumnsChanged (EventArgs e)
3493                 {
3494                         EventHandler eh = (EventHandler)(Events [AutoGenerateColumnsChangedEvent]);
3495                         if (eh != null)
3496                                 eh (this, e);
3497                 }
3498
3499                 protected internal virtual void OnAutoSizeColumnModeChanged (DataGridViewAutoSizeColumnModeEventArgs e)
3500                 {
3501                         DataGridViewAutoSizeColumnModeEventHandler eh = (DataGridViewAutoSizeColumnModeEventHandler)(Events [AutoSizeColumnModeChangedEvent]);
3502                         if (eh != null)
3503                                 eh (this, e);
3504                 }
3505
3506                 protected virtual void OnAutoSizeColumnsModeChanged (DataGridViewAutoSizeColumnsModeEventArgs e)
3507                 {
3508                         DataGridViewAutoSizeColumnsModeEventHandler eh = (DataGridViewAutoSizeColumnsModeEventHandler)(Events [AutoSizeColumnsModeChangedEvent]);
3509                         if (eh != null)
3510                                 eh (this, e);
3511                 }
3512
3513                 protected virtual void OnAutoSizeRowsModeChanged (DataGridViewAutoSizeModeEventArgs e)
3514                 {
3515                         DataGridViewAutoSizeModeEventHandler eh = (DataGridViewAutoSizeModeEventHandler)(Events [AutoSizeRowsModeChangedEvent]);
3516                         if (eh != null)
3517                                 eh (this, e);
3518                 }
3519
3520                 protected virtual void OnBackgroundColorChanged (EventArgs e)
3521                 {
3522                         EventHandler eh = (EventHandler)(Events [BackgroundColorChangedEvent]);
3523                         if (eh != null)
3524                                 eh (this, e);
3525                 }
3526
3527                 protected override void OnBindingContextChanged (EventArgs e)
3528                 {
3529                         base.OnBindingContextChanged(e);
3530                         ReBind();
3531                 }
3532
3533                 protected virtual void OnBorderStyleChanged (EventArgs e)
3534                 {
3535                         EventHandler eh = (EventHandler)(Events [BorderStyleChangedEvent]);
3536                         if (eh != null)
3537                                 eh (this, e);
3538                 }
3539
3540                 protected virtual void OnCancelRowEdit (QuestionEventArgs e) {
3541                         QuestionEventHandler eh = (QuestionEventHandler)(Events [CancelRowEditEvent]);
3542                         if (eh != null)
3543                                 eh (this, e);
3544                 }
3545
3546                 protected virtual void OnCellBeginEdit (DataGridViewCellCancelEventArgs e)
3547                 {
3548                         DataGridViewCellCancelEventHandler eh = (DataGridViewCellCancelEventHandler)(Events [CellBeginEditEvent]);
3549                         if (eh != null)
3550                                 eh (this, e);
3551                 }
3552
3553                 protected virtual void OnCellBorderStyleChanged (EventArgs e)
3554                 {
3555                         EventHandler eh = (EventHandler)(Events [CellBorderStyleChangedEvent]);
3556                         if (eh != null)
3557                                 eh (this, e);
3558                 }
3559
3560                 protected virtual void OnCellClick (DataGridViewCellEventArgs e)
3561                 {
3562                         DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3563
3564                         cell.OnClickInternal (e);
3565
3566                         DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellClickEvent]);
3567                         if (eh != null)
3568                                 eh (this, e);
3569                 }
3570
3571                 protected virtual void OnCellContentClick (DataGridViewCellEventArgs e)
3572                 {
3573                         DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3574
3575                         cell.OnContentClickInternal (e);
3576
3577                         DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellContentClickEvent]);
3578                         if (eh != null)
3579                                 eh (this, e);
3580                 }
3581
3582                 protected virtual void OnCellContentDoubleClick (DataGridViewCellEventArgs e)
3583                 {
3584                         DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3585
3586                         cell.OnContentDoubleClickInternal (e);
3587
3588                         DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellContentDoubleClickEvent]);
3589                         if (eh != null)
3590                                 eh (this, e);
3591                 }
3592
3593                 protected virtual void OnCellContextMenuStripChanged (DataGridViewCellEventArgs e)
3594                 {
3595                         DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellContextMenuStripChangedEvent]);
3596                         if (eh != null)
3597                                 eh (this, e);
3598                 }
3599
3600                 protected virtual void OnCellContextMenuStripNeeded (DataGridViewCellContextMenuStripNeededEventArgs e)
3601                 {
3602                         DataGridViewCellContextMenuStripNeededEventHandler eh = (DataGridViewCellContextMenuStripNeededEventHandler)(Events [CellContextMenuStripNeededEvent]);
3603                         if (eh != null)
3604                                 eh (this, e);
3605                 }
3606
3607                 protected virtual void OnCellDoubleClick (DataGridViewCellEventArgs e)
3608                 {
3609                         DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3610
3611                         cell.OnDoubleClickInternal (e);
3612                         DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellDoubleClickEvent]);
3613                         if (eh != null)
3614                                 eh (this, e);
3615                 }
3616
3617                 protected virtual void OnCellEndEdit (DataGridViewCellEventArgs e)
3618                 {
3619                         DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellEndEditEvent]);
3620                         if (eh != null)
3621                                 eh (this, e);
3622                 }
3623
3624                 protected virtual void OnCellEnter (DataGridViewCellEventArgs e)
3625                 {
3626                         DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3627                         cell.OnEnterInternal (e.RowIndex, true);
3628
3629                         DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellEnterEvent]);
3630                         if (eh != null)
3631                                 eh (this, e);
3632                 }
3633
3634                 protected internal virtual void OnCellErrorTextChanged (DataGridViewCellEventArgs e)
3635                 {
3636                         DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellErrorTextChangedEvent]);
3637                         if (eh != null)
3638                                 eh (this, e);
3639                 }
3640
3641                 protected virtual void OnCellErrorTextNeeded (DataGridViewCellErrorTextNeededEventArgs e)
3642                 {
3643                         DataGridViewCellErrorTextNeededEventHandler eh = (DataGridViewCellErrorTextNeededEventHandler)(Events [CellErrorTextNeededEvent]);
3644                         if (eh != null)
3645                                 eh (this, e);
3646                 }
3647
3648                 internal void OnCellFormattingInternal (DataGridViewCellFormattingEventArgs e)
3649                 {
3650                         OnCellFormatting (e);
3651                 }
3652
3653                 protected virtual void OnCellFormatting (DataGridViewCellFormattingEventArgs e)
3654                 {
3655                         DataGridViewCellFormattingEventHandler eh = (DataGridViewCellFormattingEventHandler)(Events [CellFormattingEvent]);
3656                         if (eh != null)
3657                                 eh (this, e);
3658                 }
3659
3660                 protected virtual void OnCellLeave (DataGridViewCellEventArgs e)
3661                 {
3662                         DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3663                         cell.OnLeaveInternal (e.RowIndex, true);
3664
3665                         DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellLeaveEvent]);
3666                         if (eh != null)
3667                                 eh (this, e);
3668                 }
3669
3670                 protected virtual void OnCellMouseClick (DataGridViewCellMouseEventArgs e)
3671                 {
3672                         DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3673
3674                         cell.OnMouseClickInternal (e);
3675
3676                         DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [CellMouseClickEvent]);
3677                         if (eh != null)
3678                                 eh (this, e);
3679                 }
3680
3681                 protected virtual void OnCellMouseDoubleClick (DataGridViewCellMouseEventArgs e)
3682                 {
3683                         DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3684
3685                         cell.OnMouseDoubleClickInternal (e);
3686
3687                         DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [CellMouseDoubleClickEvent]);
3688                         if (eh != null)
3689                                 eh (this, e);
3690                 }
3691
3692                 protected virtual void OnCellMouseDown (DataGridViewCellMouseEventArgs e)
3693                 {
3694
3695                         DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3696
3697                         cell.OnMouseDownInternal (e);
3698
3699                         DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [CellMouseDownEvent]);
3700                         if (eh != null)
3701                                 eh (this, e);
3702                 }
3703
3704                 protected virtual void OnCellMouseEnter (DataGridViewCellEventArgs e)
3705                 {
3706                         DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3707
3708                         cell.OnMouseEnterInternal (e.RowIndex);
3709
3710                         DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellMouseEnterEvent]);
3711                         if (eh != null)
3712                                 eh (this, e);
3713                 }
3714
3715                 protected virtual void OnCellMouseLeave (DataGridViewCellEventArgs e)
3716                 {
3717                         DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3718
3719                         cell.OnMouseLeaveInternal (e.RowIndex);
3720
3721                         DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellMouseLeaveEvent]);
3722                         if (eh != null)
3723                                 eh (this, e);
3724                 }
3725
3726                 protected virtual void OnCellMouseMove (DataGridViewCellMouseEventArgs e)
3727                 {
3728                         DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3729
3730                         cell.OnMouseMoveInternal (e);
3731
3732                         DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [CellMouseMoveEvent]);
3733                         if (eh != null)
3734                                 eh (this, e);
3735                 }
3736
3737                 protected virtual void OnCellMouseUp (DataGridViewCellMouseEventArgs e)
3738                 {
3739                         DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3740
3741                         cell.OnMouseUpInternal (e);
3742
3743                         DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [CellMouseUpEvent]);
3744                         if (eh != null)
3745                                 eh (this, e);
3746                 }
3747
3748                 internal void OnCellPaintingInternal (DataGridViewCellPaintingEventArgs e)
3749                 {
3750                         OnCellPainting (e);
3751                 }
3752
3753                 protected virtual void OnCellPainting (DataGridViewCellPaintingEventArgs e)
3754                 {
3755                         DataGridViewCellPaintingEventHandler eh = (DataGridViewCellPaintingEventHandler)(Events [CellPaintingEvent]);
3756                         if (eh != null)
3757                                 eh (this, e);
3758                 }
3759
3760                 protected internal virtual void OnCellParsing (DataGridViewCellParsingEventArgs e)
3761                 {
3762                         DataGridViewCellParsingEventHandler eh = (DataGridViewCellParsingEventHandler)(Events [CellParsingEvent]);
3763                         if (eh != null)
3764                                 eh (this, e);
3765                 }
3766
3767                 internal void OnCellStateChangedInternal (DataGridViewCellStateChangedEventArgs e) {
3768                         this.OnCellStateChanged (e);
3769                 }
3770
3771                 protected virtual void OnCellStateChanged (DataGridViewCellStateChangedEventArgs e)
3772                 {
3773                         DataGridViewCellStateChangedEventHandler eh = (DataGridViewCellStateChangedEventHandler)(Events [CellStateChangedEvent]);
3774                         if (eh != null)
3775                                 eh (this, e);
3776                 }
3777
3778                 protected virtual void OnCellStyleChanged (DataGridViewCellEventArgs e)
3779                 {
3780                         DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellStyleChangedEvent]);
3781                         if (eh != null)
3782                                 eh (this, e);
3783                 }
3784
3785                 protected virtual void OnCellStyleContentChanged (DataGridViewCellStyleContentChangedEventArgs e) {
3786                         DataGridViewCellStyleContentChangedEventHandler eh = (DataGridViewCellStyleContentChangedEventHandler)(Events [CellStyleContentChangedEvent]);
3787                         if (eh != null)
3788                                 eh (this, e);
3789                 }
3790
3791                 protected virtual void OnCellToolTipTextChanged (DataGridViewCellEventArgs e) {
3792                         DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellToolTipTextChangedEvent]);
3793                         if (eh != null)
3794                                 eh (this, e);
3795                 }
3796
3797                 protected virtual void OnCellToolTipTextNeeded (DataGridViewCellToolTipTextNeededEventArgs e)
3798                 {
3799                         DataGridViewCellToolTipTextNeededEventHandler eh = (DataGridViewCellToolTipTextNeededEventHandler)(Events [CellToolTipTextNeededEvent]);
3800                         if (eh != null)
3801                                 eh (this, e);
3802                 }
3803
3804                 protected virtual void OnCellValidated (DataGridViewCellEventArgs e)
3805                 {
3806                         DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellValidatedEvent]);
3807                         if (eh != null)
3808                                 eh (this, e);
3809                 }
3810
3811                 protected virtual void OnCellValidating (DataGridViewCellValidatingEventArgs e)
3812                 {
3813                         DataGridViewCellValidatingEventHandler eh = (DataGridViewCellValidatingEventHandler)(Events [CellValidatingEvent]);
3814                         if (eh != null)
3815                                 eh (this, e);
3816                 }
3817
3818                 protected virtual void OnCellValueChanged (DataGridViewCellEventArgs e)
3819                 {
3820                         DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellValueChangedEvent]);
3821                         if (eh != null)
3822                                 eh (this, e);
3823                 }
3824
3825                 protected internal virtual void OnCellValueNeeded (DataGridViewCellValueEventArgs e)
3826                 {
3827                         DataGridViewCellValueEventHandler eh = (DataGridViewCellValueEventHandler)(Events [CellValueNeededEvent]);
3828                         if (eh != null)
3829                                 eh (this, e);
3830                 }
3831
3832                 protected internal virtual void OnCellValuePushed (DataGridViewCellValueEventArgs e)
3833                 {
3834                         DataGridViewCellValueEventHandler eh = (DataGridViewCellValueEventHandler)(Events [CellValuePushedEvent]);
3835                         if (eh != null)
3836                                 eh (this, e);
3837                 }
3838
3839                 internal void OnColumnAddedInternal (DataGridViewColumnEventArgs e)
3840                 {
3841                         e.Column.DataColumnIndex = FindDataColumnIndex (e.Column);
3842
3843                         if (e.Column.CellTemplate != null) {
3844                                 // The first column has just been added programatically instead of
3845                                 // autogenerated so we need to create the rows for the first time.
3846                                 //
3847                                 if (!is_autogenerating_columns && columns.Count == 1)
3848                                         ReBind ();
3849
3850                                 // Add/Remove/Update the cells in the existing rows
3851                                 foreach (DataGridViewRow row in Rows) {
3852                                         if (row.Index == NewRowIndex)
3853                                                 continue;
3854
3855                                         DataGridViewCell newCell = (DataGridViewCell)e.Column.CellTemplate.Clone ();
3856                                         if (row.Cells.Count == columns.Count) {
3857                                                 DataGridViewCell oldCell = row.Cells[e.Column.Index];
3858                                                 if (currentCell != null && oldCell == currentCell)
3859                                                         currentCell = newCell;
3860                                                 // copy the value only if the cell is not-databound
3861                                                 if (!e.Column.IsDataBound && oldCell.OwningRow.DataBoundItem == null)
3862                                                         newCell.Value = oldCell.Value;
3863                                                 row.Cells.Replace (e.Column.Index, newCell);
3864                                         } else if (e.Column.Index >= row.Cells.Count)
3865                                                 row.Cells.Add (newCell);
3866                                         else
3867                                                 row.Cells.Insert (e.Column.Index, newCell);
3868                                 }
3869                         }
3870
3871                         AutoResizeColumnsInternal ();
3872                         OnColumnAdded (e);
3873                         PrepareEditingRow (false, true);
3874                 }
3875
3876                 private int FindDataColumnIndex (DataGridViewColumn column)
3877                 {
3878                         if (column != null && DataManager != null) {
3879                                 PropertyDescriptorCollection properties = DataManager.GetItemProperties();
3880                                 for (int i = 0; i < properties.Count; i++) {
3881                                         if (String.Compare (column.DataPropertyName, properties[i].Name, true) == 0)
3882                                                 return i;
3883                                 }
3884                         }
3885
3886                         return -1;
3887                 }
3888
3889                 protected virtual void OnColumnAdded (DataGridViewColumnEventArgs e)
3890                 {
3891                         DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnAddedEvent]);
3892                         if (eh != null)
3893                                 eh (this, e);
3894                 }
3895
3896                 protected internal virtual void OnColumnContextMenuStripChanged (DataGridViewColumnEventArgs e)
3897                 {
3898                         DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnContextMenuStripChangedEvent]);
3899                         if (eh != null)
3900                                 eh (this, e);
3901                 }
3902
3903                 protected internal virtual void OnColumnDataPropertyNameChanged (DataGridViewColumnEventArgs e)
3904                 {
3905                         DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnDataPropertyNameChangedEvent]);
3906                         if (eh != null)
3907                                 eh (this, e);
3908                 }
3909
3910                 protected internal virtual void OnColumnDefaultCellStyleChanged (DataGridViewColumnEventArgs e)
3911                 {
3912                         DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnDefaultCellStyleChangedEvent]);
3913                         if (eh != null)
3914                                 eh (this, e);
3915                 }
3916
3917                 protected internal virtual void OnColumnDisplayIndexChanged (DataGridViewColumnEventArgs e)
3918                 {
3919                         DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnDisplayIndexChangedEvent]);
3920                         if (eh != null)
3921                                 eh (this, e);
3922                 }
3923
3924                 protected virtual void OnColumnDividerDoubleClick (DataGridViewColumnDividerDoubleClickEventArgs e)
3925                 {
3926                         DataGridViewColumnDividerDoubleClickEventHandler eh = (DataGridViewColumnDividerDoubleClickEventHandler)(Events [ColumnDividerDoubleClickEvent]);
3927                         if (eh != null)
3928                                 eh (this, e);
3929                 }
3930
3931                 protected internal virtual void OnColumnDividerWidthChanged (DataGridViewColumnEventArgs e)
3932                 {
3933                         DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnDividerWidthChangedEvent]);
3934                         if (eh != null)
3935                                 eh (this, e);
3936                 }
3937
3938                 protected internal virtual void OnColumnHeaderCellChanged (DataGridViewColumnEventArgs e)
3939                 {
3940                         DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnHeaderCellChangedEvent]);
3941                         if (eh != null)
3942                                 eh (this, e);
3943                 }
3944
3945                 protected virtual void OnColumnHeaderMouseClick (DataGridViewCellMouseEventArgs e)
3946                 {
3947                         DataGridViewColumn col = Columns[e.ColumnIndex];
3948
3949                         if (col.SortMode == DataGridViewColumnSortMode.Automatic) {
3950                                 ListSortDirection new_order;
3951
3952                                 // Always use ascending unless we are clicking on a
3953                                 // column that is already sorted ascending.
3954                                 if (SortedColumn != col || sortOrder != SortOrder.Ascending)
3955                                         new_order = ListSortDirection.Ascending;
3956                                 else
3957                                         new_order = ListSortDirection.Descending;
3958
3959                                 Sort (col, new_order);
3960                         }
3961
3962                         DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [ColumnHeaderMouseClickEvent]);
3963                         if (eh != null)
3964                                 eh (this, e);
3965                 }
3966
3967                 protected virtual void OnColumnHeaderMouseDoubleClick (DataGridViewCellMouseEventArgs e)
3968                 {
3969                         DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [ColumnHeaderMouseDoubleClickEvent]);
3970                         if (eh != null)
3971                                 eh (this, e);
3972                 }
3973
3974                 protected virtual void OnColumnHeadersBorderStyleChanged (EventArgs e)
3975                 {
3976                         EventHandler eh = (EventHandler)(Events [ColumnHeadersBorderStyleChangedEvent]);
3977                         if (eh != null)
3978                                 eh (this, e);
3979                 }
3980
3981                 protected virtual void OnColumnHeadersDefaultCellStyleChanged (EventArgs e)
3982                 {
3983                         EventHandler eh = (EventHandler)(Events [ColumnHeadersDefaultCellStyleChangedEvent]);
3984                         if (eh != null)
3985                                 eh (this, e);
3986                 }
3987
3988                 protected virtual void OnColumnHeadersHeightChanged (EventArgs e)
3989                 {
3990                         EventHandler eh = (EventHandler)(Events [ColumnHeadersHeightChangedEvent]);
3991                         if (eh != null)
3992                                 eh (this, e);
3993                 }
3994
3995                 protected virtual void OnColumnHeadersHeightSizeModeChanged (DataGridViewAutoSizeModeEventArgs e)
3996                 {
3997                         DataGridViewAutoSizeModeEventHandler eh = (DataGridViewAutoSizeModeEventHandler)(Events [ColumnHeadersHeightSizeModeChangedEvent]);
3998                         if (eh != null)
3999                                 eh (this, e);
4000                 }
4001
4002                 protected internal virtual void OnColumnMinimumWidthChanged (DataGridViewColumnEventArgs e)
4003                 {
4004                         DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnMinimumWidthChangedEvent]);
4005                         if (eh != null)
4006                                 eh (this, e);
4007                 }
4008
4009                 protected internal virtual void OnColumnNameChanged (DataGridViewColumnEventArgs e)
4010                 {
4011                         DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnNameChangedEvent]);
4012                         if (eh != null)
4013                                 eh (this, e);
4014                 }
4015
4016                 internal void OnColumnPreRemovedInternal (DataGridViewColumnEventArgs e)
4017                 {
4018                         // The removed column should be removed from the selection too.
4019                         if (selected_columns != null)
4020                                 SetSelectedColumnCore (e.Column.Index, false);
4021
4022                         if (Columns.Count - 1 == 0) {
4023                                 MoveCurrentCell (-1, -1, true, false, false, true);
4024                                 rows.ClearInternal ();
4025                         } else if (currentCell != null && CurrentCell.ColumnIndex == e.Column.Index) {
4026                                 int nextColumnIndex = e.Column.Index;
4027                                 if (nextColumnIndex >= Columns.Count - 1)
4028                                         nextColumnIndex = Columns.Count - 1 - 1;
4029                                 MoveCurrentCell (nextColumnIndex, currentCell.RowIndex, true, false, false, true);
4030                                 if (hover_cell != null && hover_cell.ColumnIndex >= e.Column.Index)
4031                                         hover_cell = null;
4032                         }
4033                 }
4034
4035                 private void OnColumnPostRemovedInternal (DataGridViewColumnEventArgs e)
4036                 {
4037                         if (e.Column.CellTemplate != null) {
4038                                 int index = e.Column.Index;
4039
4040                                 foreach (DataGridViewRow row in Rows)
4041                                         row.Cells.RemoveAt (index);
4042                         }
4043
4044                         AutoResizeColumnsInternal ();
4045                         PrepareEditingRow (false, true);
4046
4047                         OnColumnRemoved (e);
4048                 }
4049
4050                 protected virtual void OnColumnRemoved (DataGridViewColumnEventArgs e)
4051                 {
4052                         DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnRemovedEvent]);
4053                         if (eh != null)
4054                                 eh (this, e);
4055                 }
4056
4057                 protected internal virtual void OnColumnSortModeChanged (DataGridViewColumnEventArgs e)
4058                 {
4059                         DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnSortModeChangedEvent]);
4060                         if (eh != null)
4061                                 eh (this, e);
4062                 }
4063
4064                 protected internal virtual void OnColumnStateChanged (DataGridViewColumnStateChangedEventArgs e)
4065                 {
4066                         DataGridViewColumnStateChangedEventHandler eh = (DataGridViewColumnStateChangedEventHandler)(Events [ColumnStateChangedEvent]);
4067                         if (eh != null)
4068                                 eh (this, e);
4069                 }
4070
4071                 protected internal virtual void OnColumnToolTipTextChanged (DataGridViewColumnEventArgs e)
4072                 {
4073                         DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnToolTipTextChangedEvent]);
4074                         if (eh != null)
4075                                 eh (this, e);
4076                 }
4077
4078                 protected internal virtual void OnColumnWidthChanged (DataGridViewColumnEventArgs e)
4079                 {
4080                         DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnWidthChangedEvent]);
4081                         if (eh != null)
4082                                 eh (this, e);
4083                 }
4084
4085                 protected virtual void OnCurrentCellChanged (EventArgs e)
4086                 {
4087                         EventHandler eh = (EventHandler)(Events [CurrentCellChangedEvent]);
4088                         if (eh != null)
4089                                 eh (this, e);
4090                 }
4091
4092                 protected virtual void OnCurrentCellDirtyStateChanged (EventArgs e)
4093                 {
4094                         EventHandler eh = (EventHandler)(Events [CurrentCellDirtyStateChangedEvent]);
4095                         if (eh != null)
4096                                 eh (this, e);
4097                 }
4098
4099                 protected override void OnCursorChanged (EventArgs e)
4100                 {
4101                         base.OnCursorChanged (e);
4102                 }
4103
4104                 protected virtual void OnDataBindingComplete (DataGridViewBindingCompleteEventArgs e)
4105                 {
4106                         DataGridViewBindingCompleteEventHandler eh = (DataGridViewBindingCompleteEventHandler)(Events [DataBindingCompleteEvent]);
4107                         if (eh != null)
4108                                 eh (this, e);
4109                 }
4110
4111                 protected virtual void OnDataError (bool displayErrorDialogIfNoHandler, DataGridViewDataErrorEventArgs e)
4112                 {
4113                         DataGridViewDataErrorEventHandler eh = (DataGridViewDataErrorEventHandler)(Events [DataErrorEvent]);
4114
4115                         if (eh != null)
4116                                 eh (this, e);
4117                         else if (displayErrorDialogIfNoHandler)
4118                                 MessageBox.Show (e.ToString ());
4119                 }
4120                 protected virtual void OnDataMemberChanged (EventArgs e) {
4121                         EventHandler eh = (EventHandler)(Events [DataMemberChangedEvent]);
4122                         if (eh != null)
4123                                 eh (this, e);
4124                 }
4125
4126                 protected virtual void OnDataSourceChanged (EventArgs e) {
4127                         EventHandler eh = (EventHandler)(Events [DataSourceChangedEvent]);
4128                         if (eh != null)
4129                                 eh (this, e);
4130                 }
4131
4132                 protected virtual void OnDefaultCellStyleChanged (EventArgs e) {
4133                         EventHandler eh = (EventHandler)(Events [DefaultCellStyleChangedEvent]);
4134                         if (eh != null)
4135                                 eh (this, e);
4136                 }
4137
4138                 protected virtual void OnDefaultValuesNeeded (DataGridViewRowEventArgs e) {
4139                         DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [DefaultValuesNeededEvent]);
4140                         if (eh != null)
4141                                 eh (this, e);
4142                 }
4143
4144                 protected override void OnDoubleClick (EventArgs e) {
4145                         base.OnDoubleClick(e);
4146
4147                         Point mouseLocation = this.PointToClient (Control.MousePosition);
4148                         HitTestInfo hitInfo = HitTest (mouseLocation.X, mouseLocation.Y);
4149                         if (hitInfo.Type == DataGridViewHitTestType.Cell)
4150                                 OnCellDoubleClick (new DataGridViewCellEventArgs (hitInfo.ColumnIndex, hitInfo.RowIndex));
4151                 }
4152
4153                 protected virtual void OnEditingControlShowing (DataGridViewEditingControlShowingEventArgs e) {
4154                         DataGridViewEditingControlShowingEventHandler eh = (DataGridViewEditingControlShowingEventHandler)(Events [EditingControlShowingEvent]);
4155                         if (eh != null)
4156                                 eh (this, e);
4157                 }
4158
4159                 protected virtual void OnEditModeChanged (EventArgs e)
4160                 {
4161                         EventHandler eh = (EventHandler)(Events [EditModeChangedEvent]);
4162                         if (eh != null)
4163                                 eh (this, e);
4164                 }
4165
4166                 protected override void OnEnabledChanged (EventArgs e)
4167                 {
4168                         base.OnEnabledChanged(e);
4169                 }
4170
4171                 protected override void OnEnter (EventArgs e )
4172                 {
4173                         base.OnEnter(e);
4174                 }
4175
4176                 protected override void OnGotFocus(EventArgs e)
4177                 {
4178                         base.OnGotFocus (e);
4179
4180                         // To add focus rectangle if needed
4181                         if (currentCell != null && ShowFocusCues)
4182                                 InvalidateCell (currentCell);
4183                 }
4184
4185                 protected override void OnFontChanged (EventArgs e)
4186                 {
4187                         base.OnFontChanged(e);
4188                 }
4189
4190                 protected override void OnForeColorChanged (EventArgs e)
4191                 {
4192                         base.OnForeColorChanged(e);
4193                 }
4194
4195                 protected virtual void OnGridColorChanged (EventArgs e)
4196                 {
4197                         EventHandler eh = (EventHandler)(Events [GridColorChangedEvent]);
4198                         if (eh != null)
4199                                 eh (this, e);
4200                 }
4201
4202                 protected override void OnHandleCreated (EventArgs e)
4203                 {
4204                         base.OnHandleCreated(e);
4205                         ReBind ();
4206
4207                         if (DataManager == null && CurrentCell == null && Rows.Count > 0 && Columns.Count > 0)
4208                                 MoveCurrentCell (ColumnDisplayIndexToIndex (0), 0, true, false, false, false);
4209                 }
4210
4211                 protected override void OnHandleDestroyed(EventArgs e)
4212                 {
4213                         base.OnHandleDestroyed (e);
4214                 }
4215
4216                 [EditorBrowsable (EditorBrowsableState.Advanced)]
4217                 protected override void OnKeyDown (KeyEventArgs e)
4218                 {
4219                         base.OnKeyDown (e);
4220
4221                         e.Handled = ProcessDataGridViewKey (e);
4222                 }
4223
4224                 [EditorBrowsable (EditorBrowsableState.Advanced)]
4225                 protected override void OnKeyPress (KeyPressEventArgs e)
4226                 {
4227                         base.OnKeyPress(e);
4228                 }
4229
4230                 [EditorBrowsable (EditorBrowsableState.Advanced)]
4231                 protected override void OnKeyUp (KeyEventArgs e)
4232                 {
4233                         base.OnKeyUp(e);
4234                 }
4235
4236                 protected override void OnLayout (LayoutEventArgs e)
4237                 {
4238                         if (horizontalScrollBar.Visible && verticalScrollBar.Visible) {
4239                                 horizontalScrollBar.Bounds = new Rectangle (BorderWidth, Height - BorderWidth - horizontalScrollBar.Height, Width - (2 * BorderWidth) - verticalScrollBar.Width, horizontalScrollBar.Height);
4240                                 verticalScrollBar.Bounds = new Rectangle (Width - BorderWidth - verticalScrollBar.Width, BorderWidth, verticalScrollBar.Width, Height - (2 * BorderWidth) - horizontalScrollBar.Height);
4241                         } else if (horizontalScrollBar.Visible)
4242                                 horizontalScrollBar.Bounds = new Rectangle (BorderWidth, Height - BorderWidth - horizontalScrollBar.Height, Width - (2 * BorderWidth), horizontalScrollBar.Height);
4243                         else if (verticalScrollBar.Visible)
4244                                 verticalScrollBar.Bounds = new Rectangle (Width - BorderWidth - verticalScrollBar.Width, BorderWidth, verticalScrollBar.Width,  Height - (2 * BorderWidth));
4245
4246                         AutoResizeColumnsInternal ();
4247                         Invalidate ();
4248                 }
4249
4250                 protected override void OnLeave (EventArgs e)
4251                 {
4252                         EndEdit (DataGridViewDataErrorContexts.LeaveControl);
4253                         base.OnLeave(e);
4254                 }
4255
4256                 protected override void OnLostFocus(EventArgs e)
4257                 {
4258                         base.OnLostFocus (e);
4259
4260                         // To remove focus rectangle if needed
4261                         if (currentCell != null && ShowFocusCues)
4262                                 InvalidateCell (currentCell);
4263                 }
4264
4265                 protected override void OnMouseClick (MouseEventArgs e)
4266                 {
4267                         base.OnMouseClick(e);
4268
4269                         if (column_resize_active || row_resize_active)
4270                                 return;
4271
4272                         //Console.WriteLine("Mouse: Clicks: {0}; Delta: {1}; X: {2}; Y: {3};", e.Clicks, e.Delta, e.X, e.Y);
4273                         HitTestInfo hit = HitTest (e.X, e.Y);
4274
4275                         switch (hit.Type) {
4276                                 case DataGridViewHitTestType.Cell:
4277                                         Rectangle display = GetCellDisplayRectangle (hit.ColumnIndex, hit.RowIndex, false);
4278                                         Point cellpoint = new Point (e.X - display.X, e.Y - display.Y);
4279
4280                                         OnCellMouseClick (new DataGridViewCellMouseEventArgs (hit.ColumnIndex, hit.RowIndex, cellpoint.X, cellpoint.Y, e));
4281
4282                                         DataGridViewCell cell = GetCellInternal (hit.ColumnIndex, hit.RowIndex);
4283
4284                                         if (cell.GetContentBounds (hit.RowIndex).Contains (cellpoint)) {
4285                                                 DataGridViewCellEventArgs dgvcea = new DataGridViewCellEventArgs (hit.ColumnIndex, hit.RowIndex);
4286                                                 OnCellContentClick (dgvcea);
4287                                         }
4288
4289                                         break;
4290                                 case DataGridViewHitTestType.ColumnHeader:
4291                                         Rectangle display2 = GetCellDisplayRectangle (hit.ColumnIndex, hit.RowIndex, false);
4292                                         Point cellpoint2 = new Point (e.X - display2.X, e.Y - display2.Y);
4293
4294                                         OnColumnHeaderMouseClick (new DataGridViewCellMouseEventArgs (hit.ColumnIndex, hit.RowIndex, cellpoint2.X, cellpoint2.Y, e));
4295                                         break;
4296                         }
4297                 }
4298
4299                 protected override void OnMouseDoubleClick (MouseEventArgs e)
4300                 {
4301                         base.OnMouseDoubleClick(e);
4302
4303                         HitTestInfo hitInfo = HitTest (e.X, e.Y);
4304                         if (hitInfo.Type == DataGridViewHitTestType.Cell)
4305                                 OnCellMouseDoubleClick (new DataGridViewCellMouseEventArgs (hitInfo.ColumnIndex, hitInfo.RowIndex,
4306                                                                                             hitInfo.ColumnX, hitInfo.RowY, e));
4307                 }
4308
4309                 private void DoSelectionOnMouseDown (HitTestInfo hitTest)
4310                 {
4311                         Keys modifiers = Control.ModifierKeys;
4312                         bool isControl = (modifiers & Keys.Control) != 0;
4313                         bool isShift = (modifiers & Keys.Shift) != 0;
4314                         //bool isRowHeader = hitTest.Type == DataGridViewHitTestType.RowHeader;
4315                         //bool isColHeader = hitTest.Type == DataGridViewHitTestType.ColumnHeader;
4316                         DataGridViewSelectionMode mode;
4317
4318                         switch (hitTest.Type) {
4319                         case DataGridViewHitTestType.Cell:
4320                                 mode = selectionMode;
4321                                 break;
4322                         case DataGridViewHitTestType.ColumnHeader:
4323                                 mode = selectionMode == DataGridViewSelectionMode.ColumnHeaderSelect ? DataGridViewSelectionMode.FullColumnSelect : selectionMode;
4324
4325                                 if (mode != DataGridViewSelectionMode.FullColumnSelect)
4326                                         return;
4327                                 break;
4328                         case DataGridViewHitTestType.RowHeader:
4329                                 mode = selectionMode == DataGridViewSelectionMode.RowHeaderSelect ?  DataGridViewSelectionMode.FullRowSelect : selectionMode;
4330
4331                                 if (mode != DataGridViewSelectionMode.FullRowSelect)
4332                                         return;
4333                                 break; // Handled below
4334                         default:
4335                                 return;
4336                         }
4337
4338                         if (!isControl) {
4339                                 // If SHIFT is pressed:
4340                                 //      Select all from selected_row/column/cell to current row/column/cell, unselect everything else
4341                                 // otherwise:
4342                                 //      Unselect all rows/columns/cells, select the clicked one
4343                                 int min_row, max_row;
4344                                 int min_col, max_col;
4345                                 if (!isShift) {
4346                                         selected_row = hitTest.RowIndex;
4347                                         selected_column = hitTest.ColumnIndex;
4348                                 }
4349                                 if (!isShift) {
4350                                         if (selected_row != -1)
4351                                                 selected_row = hitTest.RowIndex;
4352                                         if (selected_column != -1)
4353                                                 selected_column = hitTest.ColumnIndex;
4354                                 }
4355                                 if (selected_row >= hitTest.RowIndex) {
4356                                         min_row = hitTest.RowIndex;
4357                                         max_row = isShift ? selected_row : min_row;
4358                                 } else {
4359                                         max_row = hitTest.RowIndex;
4360                                         min_row = isShift ? selected_row : max_row;
4361                                 }
4362                                 if (selected_column >= hitTest.ColumnIndex) {
4363                                         min_col = hitTest.ColumnIndex;
4364                                         max_col = isShift ? selected_column : min_col;
4365                                 } else {
4366                                         max_col = hitTest.ColumnIndex;
4367                                         min_col = isShift ? selected_column : max_col;
4368                                 }
4369
4370                                 switch (mode) {
4371                                 case DataGridViewSelectionMode.FullRowSelect:
4372                                         for (int i = 0; i < RowCount; i++) {
4373                                                 bool select = i >= min_row && i <= max_row;
4374                                                 if (!select) {
4375                                                         for (int c = 0; c < ColumnCount; c++) {
4376                                                                 if (Rows [i].Cells [c].Selected) {
4377                                                                         SetSelectedCellCore (c, i, false);
4378                                                                 }
4379                                                         }
4380                                                 }
4381                                                 if (select != Rows [i].Selected) {
4382                                                         SetSelectedRowCore (i, select);
4383                                                 }
4384                                         }
4385                                         break;
4386                                 case DataGridViewSelectionMode.FullColumnSelect:
4387                                         for (int i = 0; i < ColumnCount; i++) {
4388                                                 bool select = i >= min_col && i <= max_col;
4389                                                 if (!select) {
4390                                                         for (int r = 0; r < RowCount; r++) {
4391                                                                 if (Rows [r].Cells [i].Selected) {
4392                                                                         SetSelectedCellCore (i, r, false);
4393                                                                 }
4394                                                         }
4395                                                 }
4396                                                 if (select != Columns [i].Selected) {
4397                                                         SetSelectedColumnCore (i, select);
4398                                                 }
4399                                         }
4400                                         break;
4401                                 case DataGridViewSelectionMode.ColumnHeaderSelect:
4402                                 case DataGridViewSelectionMode.RowHeaderSelect:
4403                                         //break;
4404                                 case DataGridViewSelectionMode.CellSelect:
4405                                         if (!isShift) {
4406                                                 for (int c = 0; c < ColumnCount; c++) {
4407                                                         if (columns [c].Selected)
4408                                                                 SetSelectedColumnCore (c, false);
4409                                                 }
4410
4411                                                 for (int r = 0; r < RowCount; r++) {
4412                                                         if (rows [r].Selected)
4413                                                                 SetSelectedRowCore (r, false);
4414                                                 }
4415                                         }
4416                                         for (int r = 0; r < RowCount; r++) {
4417                                                 for (int c = 0; c < ColumnCount; c++) {
4418                                                         bool select = (r >= min_row && r <= max_row) && (c >= min_col && c <= max_col);
4419                                                         if (select != Rows [r].Cells [c].Selected)
4420                                                                 SetSelectedCellCore (c, r, select);
4421                                                 }
4422                                         }
4423                                         break;
4424                                 }
4425
4426                         } else if (isControl) {
4427                                 // Switch the selected state of the row.
4428                                 switch (mode) {
4429                                 case DataGridViewSelectionMode.FullRowSelect:
4430                                         SetSelectedRowCore (hitTest.RowIndex, !rows [hitTest.RowIndex].Selected);
4431                                         break;
4432                                 case DataGridViewSelectionMode.FullColumnSelect:
4433                                         SetSelectedColumnCore (hitTest.ColumnIndex, !columns [hitTest.ColumnIndex].Selected);
4434                                         break;
4435                                 case DataGridViewSelectionMode.ColumnHeaderSelect:
4436                                 case DataGridViewSelectionMode.RowHeaderSelect:
4437                                         //break;
4438                                 case DataGridViewSelectionMode.CellSelect:
4439                                         if (hitTest.ColumnIndex >= 0 && hitTest.RowIndex >= 0) {
4440                                                 SetSelectedCellCore (hitTest.ColumnIndex, hitTest.RowIndex, !Rows [hitTest.RowIndex].Cells [hitTest.ColumnIndex].Selected);
4441                                         }
4442                                         break;
4443                                 }
4444                         }
4445
4446                 }
4447
4448                 protected override void OnMouseDown (MouseEventArgs e)
4449                 {
4450                         base.OnMouseDown(e);
4451
4452                         if (!EndEdit ())
4453                                 return;
4454
4455                         HitTestInfo hitTest = HitTest(e.X, e.Y);
4456
4457                         DataGridViewCell cell = null;
4458                         DataGridViewRow row = null;
4459                         Rectangle cellBounds;
4460
4461                         if ((hitTest.Type == DataGridViewHitTestType.ColumnHeader ||
4462                              (hitTest.Type == DataGridViewHitTestType.Cell && !ColumnHeadersVisible))
4463                             && MouseOverColumnResize (hitTest.ColumnIndex, e.X)) {
4464                                 if (e.Clicks == 2) {
4465                                         AutoResizeColumn (hitTest.ColumnIndex);
4466                                         return;
4467                                 }
4468
4469                                 resize_band = hitTest.ColumnIndex;
4470                                 column_resize_active = true;
4471                                 resize_band_start = e.X;
4472                                 resize_band_delta = 0;
4473                                 DrawVerticalResizeLine (resize_band_start);
4474                                 return;
4475                         }
4476
4477                         if ((hitTest.Type == DataGridViewHitTestType.RowHeader ||
4478                              (hitTest.Type == DataGridViewHitTestType.Cell && !RowHeadersVisible))
4479                             && MouseOverRowResize (hitTest.RowIndex, e.Y)) {
4480                                 if (e.Clicks == 2) {
4481                                         AutoResizeRow (hitTest.RowIndex);
4482                                         return;
4483                                 }
4484
4485                                 resize_band = hitTest.RowIndex;
4486                                 row_resize_active = true;
4487                                 resize_band_start = e.Y;
4488                                 resize_band_delta = 0;
4489                                 DrawHorizontalResizeLine (resize_band_start);
4490                                 return;
4491                         }
4492
4493                         if (hitTest.Type == DataGridViewHitTestType.Cell) {
4494                                 row = rows [hitTest.RowIndex];
4495                                 cell = row.Cells [hitTest.ColumnIndex];
4496                                 SetCurrentCellAddressCore (cell.ColumnIndex, cell.RowIndex, false, true, true);
4497                                 cellBounds = GetCellDisplayRectangle (hitTest.ColumnIndex, hitTest.RowIndex, false);
4498                                 OnCellMouseDown (new DataGridViewCellMouseEventArgs (hitTest.ColumnIndex, hitTest.RowIndex, e.X - cellBounds.X, e.Y - cellBounds.Y, e));
4499                                 OnCellClick (new DataGridViewCellEventArgs (hitTest.ColumnIndex, hitTest.RowIndex));
4500                         }
4501
4502                         DoSelectionOnMouseDown (hitTest);
4503
4504                         if (hitTest.Type != DataGridViewHitTestType.Cell) {
4505                                 if (hitTest.Type == DataGridViewHitTestType.ColumnHeader)
4506                                         pressed_header_cell = columns [hitTest.ColumnIndex].HeaderCell;
4507                                 else if (hitTest.Type == DataGridViewHitTestType.RowHeader)
4508                                         pressed_header_cell = rows [hitTest.RowIndex].HeaderCell;
4509                                 Invalidate ();
4510                                 return;
4511                         }
4512
4513                         Invalidate();
4514                         return;
4515                 }
4516
4517                 private void UpdateBindingPosition (int position)
4518                 {
4519                         if (DataManager != null)
4520                                 DataManager.Position = position;
4521                 }
4522
4523                 protected override void OnMouseEnter (EventArgs e)
4524                 {
4525                         base.OnMouseEnter(e);
4526                 }
4527
4528                 protected override void OnMouseLeave (EventArgs e)
4529                 {
4530                         base.OnMouseLeave (e);
4531
4532                         if (hover_cell != null) {
4533                                 OnCellMouseLeave (new DataGridViewCellEventArgs (hover_cell.ColumnIndex, hover_cell.RowIndex));
4534                                 hover_cell = null;
4535                         }
4536
4537                         EnteredHeaderCell = null;
4538                 }
4539
4540                 protected override void OnMouseMove (MouseEventArgs e)
4541                 {
4542                         base.OnMouseMove (e);
4543
4544                         if (column_resize_active) {
4545                                 // Erase the old line
4546                                 DrawVerticalResizeLine (resize_band_start + resize_band_delta);
4547
4548                                 resize_band_delta = e.X - resize_band_start;
4549
4550                                 // Draw the new line
4551                                 DrawVerticalResizeLine (resize_band_start + resize_band_delta);
4552                                 return;
4553                         }
4554
4555                         if (row_resize_active) {
4556                                 // Erase the old line
4557                                 DrawHorizontalResizeLine (resize_band_start + resize_band_delta);
4558
4559                                 resize_band_delta = e.Y - resize_band_start;
4560
4561                                 // Draw the new line
4562                                 DrawHorizontalResizeLine (resize_band_start + resize_band_delta);
4563                                 return;
4564                         }
4565
4566                         Cursor new_cursor = Cursors.Default;
4567                         HitTestInfo hit = this.HitTest (e.X, e.Y);
4568
4569                         if (hit.Type == DataGridViewHitTestType.ColumnHeader ||
4570                             (!ColumnHeadersVisible && hit.Type == DataGridViewHitTestType.Cell && MouseOverColumnResize (hit.ColumnIndex, e.X))) {
4571                                 EnteredHeaderCell = Columns [hit.ColumnIndex].HeaderCell;
4572                                 if (MouseOverColumnResize (hit.ColumnIndex, e.X))
4573                                         new_cursor = Cursors.VSplit;
4574                         } else if (!RowHeadersVisible && hit.Type == DataGridViewHitTestType.Cell && MouseOverRowResize (hit.RowIndex, e.Y)) {
4575                                 EnteredHeaderCell = Rows[hit.RowIndex].HeaderCell;
4576                                 new_cursor = Cursors.HSplit;
4577                         } else if (hit.Type == DataGridViewHitTestType.Cell) {
4578                                 EnteredHeaderCell = null;
4579
4580                                 DataGridViewCell new_cell = GetCellInternal (hit.ColumnIndex, hit.RowIndex);
4581
4582                                 // Check if we have moved into an error icon area
4583                                 Rectangle icon = new_cell.ErrorIconBounds;
4584
4585                                 if (!icon.IsEmpty) {
4586                                         Point loc = GetCellDisplayRectangle (hit.ColumnIndex, hit.RowIndex, false).Location;
4587
4588                                         icon.X += loc.X;
4589                                         icon.Y += loc.Y;
4590
4591                                         if (icon.Contains (e.X, e.Y)) {
4592                                                 if (tooltip_currently_showing != new_cell)
4593                                                         MouseEnteredErrorIcon (new_cell);
4594                                         } else
4595                                                 MouseLeftErrorIcon (new_cell);
4596                                 }
4597
4598                                 Cursor = new_cursor;
4599
4600                                 // We have never been in a cell before
4601                                 if (hover_cell == null) {
4602                                         hover_cell = new_cell;
4603                                         OnCellMouseEnter (new DataGridViewCellEventArgs (hit.ColumnIndex, hit.RowIndex));
4604
4605                                         Rectangle display = GetCellDisplayRectangle (hit.ColumnIndex, hit.RowIndex, false);
4606                                         OnCellMouseMove (new DataGridViewCellMouseEventArgs (hit.ColumnIndex, hit.RowIndex, e.X - display.X, e.Y - display.Y, e));
4607
4608                                         return;
4609                                 }
4610
4611                                 // Were we already in this cell?
4612                                 if (hover_cell.RowIndex == hit.RowIndex && hover_cell.ColumnIndex == hit.ColumnIndex) {
4613                                         Rectangle display = GetCellDisplayRectangle (hit.ColumnIndex, hit.RowIndex, false);
4614                                         OnCellMouseMove (new DataGridViewCellMouseEventArgs (hit.ColumnIndex, hit.RowIndex, e.X - display.X, e.Y - display.Y, e));
4615
4616                                         return;
4617                                 }
4618
4619                                 // We are changing cells
4620                                 OnCellMouseLeave (new DataGridViewCellEventArgs (hover_cell.ColumnIndex, hover_cell.RowIndex));
4621
4622                                 hover_cell = new_cell;
4623
4624                                 OnCellMouseEnter (new DataGridViewCellEventArgs (hit.ColumnIndex, hit.RowIndex));
4625
4626                                 Rectangle display2 = GetCellDisplayRectangle (hit.ColumnIndex, hit.RowIndex, false);
4627                                 OnCellMouseMove (new DataGridViewCellMouseEventArgs (hit.ColumnIndex, hit.RowIndex, e.X - display2.X, e.Y - display2.Y, e));
4628
4629                                 return;
4630                         } else if (hit.Type == DataGridViewHitTestType.RowHeader) {
4631                                 DataGridViewRowHeaderCell new_cell = Rows[hit.RowIndex].HeaderCell;
4632
4633                                 EnteredHeaderCell = new_cell;
4634
4635                                 if (MouseOverRowResize (hit.RowIndex, e.Y))
4636                                         new_cursor = Cursors.HSplit;
4637
4638                                 // Check if we have moved into an error icon area
4639                                 Rectangle icon = new_cell.InternalErrorIconsBounds;
4640
4641                                 if (!icon.IsEmpty) {
4642                                         Point loc = GetCellDisplayRectangle (0, hit.RowIndex, false).Location;
4643
4644                                         icon.X += BorderWidth;
4645                                         icon.Y += loc.Y;
4646
4647                                         if (icon.Contains (e.X, e.Y)) {
4648                                                 if (tooltip_currently_showing != new_cell)
4649                                                         MouseEnteredErrorIcon (new_cell);
4650                                         } else
4651                                                 MouseLeftErrorIcon (new_cell);
4652                                 }
4653                         } else if (hit.Type == DataGridViewHitTestType.TopLeftHeader) {
4654                                 EnteredHeaderCell = null;
4655
4656                                 DataGridViewTopLeftHeaderCell new_cell = (DataGridViewTopLeftHeaderCell)TopLeftHeaderCell;
4657
4658                                 // Check if we have moved into an error icon area
4659                                 Rectangle icon = new_cell.InternalErrorIconsBounds;
4660
4661                                 if (!icon.IsEmpty) {
4662                                         Point loc = Point.Empty;
4663
4664                                         icon.X += BorderWidth;
4665                                         icon.Y += loc.Y;
4666
4667                                         if (icon.Contains (e.X, e.Y)) {
4668                                                 if (tooltip_currently_showing != new_cell)
4669                                                         MouseEnteredErrorIcon (new_cell);
4670                                         } else
4671                                                 MouseLeftErrorIcon (new_cell);
4672                                 }
4673
4674                         } else {
4675                                 EnteredHeaderCell = null;
4676
4677                                 // We have left the cell area
4678                                 if (hover_cell != null) {
4679                                         OnCellMouseLeave (new DataGridViewCellEventArgs (hover_cell.ColumnIndex, hover_cell.RowIndex));
4680                                         hover_cell = null;
4681                                 }
4682                         }
4683
4684                         Cursor = new_cursor;
4685                 }
4686
4687                 protected override void OnMouseUp (MouseEventArgs e)
4688                 {
4689                         base.OnMouseUp(e);
4690
4691                         if (column_resize_active) {
4692                                 column_resize_active = false;
4693
4694                                 if (resize_band_delta + Columns[resize_band].Width < 0)
4695                                         resize_band_delta = -Columns[resize_band].Width;
4696
4697                                 Columns[resize_band].Width = Math.Max (resize_band_delta + Columns[resize_band].Width, Columns[resize_band].MinimumWidth);
4698                                 Invalidate ();
4699                                 return;
4700                         }
4701
4702                         if (row_resize_active) {
4703                                 row_resize_active = false;
4704
4705                                 if (resize_band_delta + Rows[resize_band].Height < 0)
4706                                         resize_band_delta = -Rows[resize_band].Height;
4707
4708                                 Rows[resize_band].Height = Math.Max (resize_band_delta + Rows[resize_band].Height, Rows[resize_band].MinimumHeight);
4709                                 Invalidate ();
4710                                 return;
4711                         }
4712
4713                         HitTestInfo hit = this.HitTest (e.X, e.Y);
4714
4715                         if (hit.Type == DataGridViewHitTestType.Cell) {
4716                                 Rectangle display = GetCellDisplayRectangle (hit.ColumnIndex, hit.RowIndex, false);
4717                                 OnCellMouseUp (new DataGridViewCellMouseEventArgs (hit.ColumnIndex, hit.RowIndex, e.X - display.X, e.Y - display.Y, e));
4718                         }
4719
4720                         if (pressed_header_cell != null) {
4721                                 DataGridViewHeaderCell cell = pressed_header_cell;
4722                                 pressed_header_cell = null;
4723                                 if (ThemeEngine.Current.DataGridViewHeaderCellHasPressedStyle (this))
4724                                         Invalidate (GetHeaderCellBounds (cell));
4725                         }
4726                 }
4727
4728                 protected override void OnMouseWheel (MouseEventArgs e)
4729                 {
4730                         base.OnMouseWheel(e);
4731
4732                         int delta = SystemInformation.MouseWheelScrollLines * verticalScrollBar.SmallChange;
4733                         if (e.Delta < 0)
4734                                 verticalScrollBar.SafeValueSet (verticalScrollBar.Value + delta);
4735                         else
4736                                 verticalScrollBar.SafeValueSet (verticalScrollBar.Value - delta);
4737
4738                         OnVScrollBarScroll (this, new ScrollEventArgs (ScrollEventType.ThumbPosition, verticalScrollBar.Value));
4739                 }
4740
4741                 protected virtual void OnMultiSelectChanged (EventArgs e)
4742                 {
4743                         EventHandler eh = (EventHandler)(Events [MultiSelectChangedEvent]);
4744                         if (eh != null) eh (this, e);
4745                 }
4746
4747                 protected virtual void OnNewRowNeeded (DataGridViewRowEventArgs e) {
4748                         DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [NewRowNeededEvent]);
4749                         if (eh != null) eh (this, e);
4750                 }
4751
4752                 int first_row_index = 0;
4753                 internal int first_col_index = 0;
4754
4755                 protected override void OnPaint (PaintEventArgs e)
4756                 {
4757                         Graphics g = e.Graphics;
4758                         Rectangle bounds = ClientRectangle;
4759
4760                         // Paint the background
4761                         PaintBackground (g, e.ClipRectangle, bounds);
4762
4763                         List<DataGridViewColumn> sortedColumns = columns.ColumnDisplayIndexSortedArrayList;
4764
4765                         // Take borders into account
4766                         bounds.Inflate (-BorderWidth, -BorderWidth);
4767
4768                         // Paint the top left cell
4769                         if (rowHeadersVisible && columnHeadersVisible && ColumnCount > 0) {
4770                                 Rectangle topleftbounds = new Rectangle (bounds.X, bounds.Y, rowHeadersWidth, columnHeadersHeight);
4771
4772                                 TopLeftHeaderCell.PaintWork (g, e.ClipRectangle, topleftbounds, -1, TopLeftHeaderCell.State, ColumnHeadersDefaultCellStyle, AdvancedColumnHeadersBorderStyle, DataGridViewPaintParts.All);
4773                         }
4774
4775                         // Paint the column headers
4776                         if (columnHeadersVisible) {
4777                                 Rectangle headerBounds = bounds;
4778                                 headerBounds.Height = columnHeadersHeight;
4779
4780                                 if (rowHeadersVisible)
4781                                         headerBounds.X += rowHeadersWidth;
4782
4783                                 for (int index = first_col_index; index < sortedColumns.Count; index++) {
4784                                         DataGridViewColumn col = sortedColumns[index];
4785
4786                                         if (!col.Visible)
4787                                                 continue;
4788
4789                                         headerBounds.Width = col.Width;
4790                                         DataGridViewCell cell = col.HeaderCell;
4791
4792                                         DataGridViewAdvancedBorderStyle intermediateBorderStyle = (DataGridViewAdvancedBorderStyle)((ICloneable)this.AdvancedColumnHeadersBorderStyle).Clone ();
4793                                         DataGridViewAdvancedBorderStyle borderStyle = AdjustColumnHeaderBorderStyle (this.AdvancedColumnHeadersBorderStyle, intermediateBorderStyle, cell.ColumnIndex == 0, cell.ColumnIndex == columns.Count - 1);
4794
4795                                         cell.PaintWork (g, e.ClipRectangle, headerBounds, -1, cell.State, cell.InheritedStyle, borderStyle, DataGridViewPaintParts.All);
4796
4797                                         headerBounds.X += col.Width;
4798                                 }
4799
4800                                 bounds.Y += columnHeadersHeight;
4801                         }
4802
4803                         // Reset not displayed columns to !Displayed
4804                         for (int i = 0; i < first_col_index; i++)
4805                                 Columns[i].DisplayedInternal = false;
4806
4807                         int gridWidth = rowHeadersVisible ? rowHeadersWidth : 0;
4808
4809                         // Set Displayed columns
4810                         for (int i = first_col_index; i < Columns.Count; i++) {
4811                                 DataGridViewColumn col = Columns.ColumnDisplayIndexSortedArrayList[i];
4812
4813                                 if (!col.Visible)
4814                                         continue;
4815
4816                                 col.DisplayedInternal = true;
4817                                 gridWidth += col.Width;
4818                                 if (gridWidth >= Width)
4819                                         break;
4820                         }
4821
4822                         // Reset all not displayed rows to !Displayed
4823                         for (int i = 0; i < first_row_index; i++)
4824                                 GetRowInternal (i).DisplayedInternal = false;
4825
4826                         // Draw rows
4827                         for (int index = first_row_index; index < Rows.Count; index++) {
4828                                 DataGridViewRow row = Rows[index];
4829                                 if (!row.Visible)
4830                                         continue;
4831                                 GetRowInternal (index).DisplayedInternal = true;
4832
4833                                 bounds.Height = row.Height;
4834                                 bool is_first = row.Index == 0;
4835                                 bool is_last = row.Index == rows.Count - 1;
4836
4837                                 row.Paint (g, e.ClipRectangle, bounds, row.Index, row.GetState (row.Index), is_first, is_last);
4838
4839                                 bounds.Y += bounds.Height;
4840                                 bounds.X = BorderWidth;
4841
4842                                 if (bounds.Y >= ClientSize.Height - (horizontalScrollBar.Visible ? horizontalScrollBar.Height : 0))
4843                                         break;
4844                         }
4845
4846                         RefreshScrollBars ();
4847
4848                         // Paint the bottom right square if both scrollbars are displayed
4849                         if (horizontalScrollBar.Visible && verticalScrollBar.Visible)
4850                                 g.FillRectangle (SystemBrushes.Control, new Rectangle (horizontalScrollBar.Right, verticalScrollBar.Bottom, verticalScrollBar.Width, horizontalScrollBar.Height));
4851
4852                         // Paint the border
4853                         bounds = ClientRectangle;
4854
4855                         switch (BorderStyle) {
4856                                 case BorderStyle.FixedSingle:
4857                                         g.DrawRectangle (Pens.Black, new Rectangle (bounds.Left, bounds.Top, bounds.Width - 1, bounds.Height - 1));
4858                                         break;
4859                                 case BorderStyle.Fixed3D:
4860                                         ControlPaint.DrawBorder3D (g, bounds, Border3DStyle.Sunken);
4861                                         break;
4862                         }
4863
4864                         // Call the base impl at the end.
4865                         base.OnPaint(e);
4866                 }
4867
4868                 private void RefreshScrollBars ()
4869                 {
4870                         int gridWidth = 0;
4871                         int gridHeight = 0;
4872
4873                         foreach (DataGridViewColumn col in columns.ColumnDisplayIndexSortedArrayList)
4874                                 if (col.Visible)
4875                                         gridWidth += col.Width;
4876
4877                         foreach (DataGridViewRow row in Rows)
4878                                 if (row.Visible)
4879                                         gridHeight += row.Height;
4880
4881                         if (rowHeadersVisible)
4882                                 gridWidth += rowHeadersWidth;
4883                         if (columnHeadersVisible)
4884                                 gridHeight += columnHeadersHeight;
4885
4886                         bool horizontalVisible = false;
4887                         bool verticalVisible = false;
4888
4889                         if (AutoSize) {
4890                                 if (gridWidth > Size.Width || gridHeight > Size.Height)
4891                                         Size = new Size(gridWidth, gridHeight);
4892                         }
4893                         else {
4894                                 if (gridWidth > Size.Width)
4895                                         horizontalVisible = true;
4896                                 if (gridHeight > Size.Height)
4897                                         verticalVisible = true;
4898
4899                                 if (horizontalScrollBar.Visible && (gridHeight + horizontalScrollBar.Height) > Size.Height)
4900                                         verticalVisible = true;
4901                                 if (verticalScrollBar.Visible && (gridWidth + verticalScrollBar.Width) > Size.Width)
4902                                         horizontalVisible = true;
4903
4904                                 if (horizontalVisible) {
4905                                         horizontalScrollBar.Minimum = 0;
4906                                         horizontalScrollBar.Maximum = gridWidth;
4907                                         horizontalScrollBar.SmallChange = Columns[first_col_index].Width;
4908                                         int largeChange = ClientSize.Width - rowHeadersWidth - horizontalScrollBar.Height;
4909                                         if (largeChange <= 0)
4910                                                 largeChange = ClientSize.Width;
4911                                         horizontalScrollBar.LargeChange = largeChange;
4912                                 }
4913
4914                                 if (verticalVisible) {
4915                                         verticalScrollBar.Minimum = 0;
4916                                         verticalScrollBar.Maximum = gridHeight;
4917                                         int first_row_height = Rows.Count > 0 ? Rows[Math.Min (Rows.Count - 1, first_row_index)].Height : 0;
4918                                         verticalScrollBar.SmallChange = first_row_height + 1;
4919                                         int largeChange = ClientSize.Height - columnHeadersHeight - verticalScrollBar.Width;
4920                                         if (largeChange <= 0)
4921                                                 largeChange = ClientSize.Height;
4922                                         verticalScrollBar.LargeChange = largeChange;
4923                                 }
4924
4925                                 // Force the visibility of the scrollbars *after* computing the scrolling values,
4926                                 // as we need them *always* for navigation purposes.
4927                                 if (scrollBars != ScrollBars.Vertical && scrollBars != ScrollBars.Both)
4928                                         verticalVisible = false;
4929                                 if (scrollBars != ScrollBars.Horizontal && scrollBars != ScrollBars.Both)
4930                                         horizontalVisible = false;
4931
4932                                 // MSNET compatibility here
4933                                 if (RowCount <= 1)
4934                                         verticalVisible = false;
4935
4936
4937                         }
4938
4939                         horizontalScrollBar.Visible = horizontalVisible;
4940                         verticalScrollBar.Visible = verticalVisible;
4941                 }
4942
4943                 protected virtual void OnReadOnlyChanged (EventArgs e) {
4944                         EventHandler eh = (EventHandler)(Events [ReadOnlyChangedEvent]);
4945                         if (eh != null)
4946                                 eh (this, e);
4947                 }
4948
4949                 protected override void OnResize (EventArgs e) {
4950                         base.OnResize(e);
4951                         AutoResizeColumnsInternal ();
4952
4953                         OnVScrollBarScroll (this, new ScrollEventArgs (ScrollEventType.ThumbPosition, verticalScrollBar.Value));
4954                         OnHScrollBarScroll (this, new ScrollEventArgs (ScrollEventType.ThumbPosition, horizontalScrollBar.Value));
4955                 }
4956
4957                 protected override void OnRightToLeftChanged (EventArgs e) {
4958                         base.OnRightToLeftChanged(e);
4959                 }
4960
4961                 // In MSDN2 documentation there's no internal here
4962                 protected internal virtual void OnRowContextMenuStripChanged (DataGridViewRowEventArgs e)
4963                 {
4964                         DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowContextMenuStripChangedEvent]);
4965                         if (eh != null) eh (this, e);
4966                 }
4967
4968                 protected virtual void OnRowContextMenuStripNeeded (DataGridViewRowContextMenuStripNeededEventArgs e)
4969                 {
4970                         DataGridViewRowContextMenuStripNeededEventHandler eh = (DataGridViewRowContextMenuStripNeededEventHandler)(Events [RowContextMenuStripNeededEvent]);
4971                         if (eh != null) eh (this, e);
4972                 }
4973
4974                 protected internal virtual void OnRowDefaultCellStyleChanged (DataGridViewRowEventArgs e)
4975                 {
4976                         DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowDefaultCellStyleChangedEvent]);
4977                         if (eh != null) eh (this, e);
4978                 }
4979
4980                 protected virtual void OnRowDirtyStateNeeded (QuestionEventArgs e)
4981                 {
4982                         QuestionEventHandler eh = (QuestionEventHandler)(Events [RowDirtyStateNeededEvent]);
4983                         if (eh != null) eh (this, e);
4984                 }
4985
4986                 protected virtual void OnRowDividerDoubleClick (DataGridViewRowDividerDoubleClickEventArgs e)
4987                 {
4988                         DataGridViewRowDividerDoubleClickEventHandler eh = (DataGridViewRowDividerDoubleClickEventHandler)(Events [RowDividerDoubleClickEvent]);
4989                         if (eh != null) eh (this, e);
4990                 }
4991
4992                 protected virtual void OnRowDividerHeightChanged (DataGridViewRowEventArgs e)
4993                 {
4994                         DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowDividerHeightChangedEvent]);
4995                         if (eh != null) eh (this, e);
4996                 }
4997
4998                 protected virtual void OnRowEnter (DataGridViewCellEventArgs e)
4999                 {
5000                         DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [RowEnterEvent]);
5001                         if (eh != null) eh (this, e);
5002                 }
5003
5004                 protected internal virtual void OnRowErrorTextChanged (DataGridViewRowEventArgs e)
5005                 {
5006                         DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowErrorTextChangedEvent]);
5007                         if (eh != null) eh (this, e);
5008                 }
5009
5010                 protected virtual void OnRowErrorTextNeeded (DataGridViewRowErrorTextNeededEventArgs e)
5011                 {
5012                         DataGridViewRowErrorTextNeededEventHandler eh = (DataGridViewRowErrorTextNeededEventHandler)(Events [RowErrorTextNeededEvent]);
5013                         if (eh != null) eh (this, e);
5014                 }
5015
5016                 protected internal virtual void OnRowHeaderCellChanged (DataGridViewRowEventArgs e)
5017                 {
5018                         DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowHeaderCellChangedEvent]);
5019                         if (eh != null) eh (this, e);
5020                 }
5021
5022                 protected virtual void OnRowHeaderMouseClick (DataGridViewCellMouseEventArgs e)
5023                 {
5024                         DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [RowHeaderMouseClickEvent]);
5025                         if (eh != null) eh (this, e);
5026                 }
5027
5028                 protected virtual void OnRowHeaderMouseDoubleClick (DataGridViewCellMouseEventArgs e)
5029                 {
5030                         DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [RowHeaderMouseDoubleClickEvent]);
5031                         if (eh != null) eh (this, e);
5032                 }
5033
5034                 protected virtual void OnRowHeadersBorderStyleChanged (EventArgs e)
5035                 {
5036                         EventHandler eh = (EventHandler)(Events [RowHeadersBorderStyleChangedEvent]);
5037                         if (eh != null) eh (this, e);
5038                 }
5039
5040                 protected virtual void OnRowHeadersDefaultCellStyleChanged (EventArgs e)
5041                 {
5042                         EventHandler eh = (EventHandler)(Events [RowHeadersDefaultCellStyleChangedEvent]);
5043                         if (eh != null) eh (this, e);
5044                 }
5045
5046                 protected virtual void OnRowHeadersWidthChanged (EventArgs e)
5047                 {
5048                         EventHandler eh = (EventHandler)(Events [RowHeadersWidthChangedEvent]);
5049                         if (eh != null) eh (this, e);
5050                 }
5051
5052                 protected virtual void OnRowHeadersWidthSizeModeChanged (DataGridViewAutoSizeModeEventArgs e)
5053                 {
5054                         DataGridViewAutoSizeModeEventHandler eh = (DataGridViewAutoSizeModeEventHandler)(Events [RowHeadersWidthSizeModeChangedEvent]);
5055                         if (eh != null) eh (this, e);
5056                 }
5057
5058                 protected internal virtual void OnRowHeightChanged (DataGridViewRowEventArgs e)
5059                 {
5060                         UpdateRowHeightInfo (e.Row.Index, false);
5061                         DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowHeightChangedEvent]);
5062                         if (eh != null) eh (this, e);
5063                 }
5064
5065                 protected virtual void OnRowHeightInfoNeeded (DataGridViewRowHeightInfoNeededEventArgs e)
5066                 {
5067                         DataGridViewRowHeightInfoNeededEventHandler eh = (DataGridViewRowHeightInfoNeededEventHandler)(Events [RowHeightInfoNeededEvent]);
5068                         if (eh != null) eh (this, e);
5069                 }
5070
5071                 protected virtual void OnRowHeightInfoPushed (DataGridViewRowHeightInfoPushedEventArgs e)
5072                 {
5073                         DataGridViewRowHeightInfoPushedEventHandler eh = (DataGridViewRowHeightInfoPushedEventHandler)(Events [RowHeightInfoPushedEvent]);
5074                         if (eh != null) eh (this, e);
5075                 }
5076
5077                 protected virtual void OnRowLeave (DataGridViewCellEventArgs e)
5078                 {
5079                         DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [RowLeaveEvent]);
5080                         if (eh != null) eh (this, e);
5081                 }
5082
5083                 protected internal virtual void OnRowMinimumHeightChanged (DataGridViewRowEventArgs e)
5084                 {
5085                         DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowMinimumHeightChangedEvent]);
5086                         if (eh != null) eh (this, e);
5087                 }
5088
5089                 protected internal virtual void OnRowPostPaint (DataGridViewRowPostPaintEventArgs e)
5090                 {
5091                         DataGridViewRowPostPaintEventHandler eh = (DataGridViewRowPostPaintEventHandler)(Events [RowPostPaintEvent]);
5092                         if (eh != null) eh (this, e);
5093                 }
5094
5095                 protected internal virtual void OnRowPrePaint (DataGridViewRowPrePaintEventArgs e)
5096                 {
5097                         DataGridViewRowPrePaintEventHandler eh = (DataGridViewRowPrePaintEventHandler)(Events [RowPrePaintEvent]);
5098                         if (eh != null) eh (this, e);
5099                 }
5100
5101                 internal void OnRowsAddedInternal (DataGridViewRowsAddedEventArgs e)
5102                 {
5103                         if (hover_cell != null && hover_cell.RowIndex >= e.RowIndex)
5104                                 hover_cell = null;
5105
5106                         // Select the first row if we are not databound.
5107                         // If we are databound selection is managed by the data manager.
5108                         if (IsHandleCreated && DataManager == null && CurrentCell == null && Rows.Count > 0 && Columns.Count > 0)
5109                                 MoveCurrentCell (ColumnDisplayIndexToIndex (0), 0, true, false, false, true);
5110
5111                         AutoResizeColumnsInternal ();
5112                         if (VirtualMode) {
5113                                 for (int i = 0; i < e.RowCount; i++)
5114                                         UpdateRowHeightInfo (e.RowIndex + i, false);
5115                         }
5116
5117                         Invalidate ();
5118                         OnRowsAdded (e);
5119                 }
5120
5121                 protected virtual void OnRowsAdded (DataGridViewRowsAddedEventArgs e)
5122                 {
5123                         DataGridViewRowsAddedEventHandler eh = (DataGridViewRowsAddedEventHandler)(Events [RowsAddedEvent]);
5124                         if (eh != null) eh (this, e);
5125                 }
5126
5127                 protected virtual void OnRowsDefaultCellStyleChanged (EventArgs e)
5128                 {
5129                         EventHandler eh = (EventHandler)(Events [RowsDefaultCellStyleChangedEvent]);
5130                         if (eh != null) eh (this, e);
5131                 }
5132
5133                 internal void OnRowsPreRemovedInternal (DataGridViewRowsRemovedEventArgs e)
5134                 {
5135                         // All removed rows should be removed from the selection too.
5136                         if (selected_rows != null)
5137                         {
5138                                 int lastRowIndex = e.RowIndex + e.RowCount;
5139                                 for (int rowIndex = e.RowIndex; rowIndex < lastRowIndex; ++rowIndex)
5140                                         SetSelectedRowCore (rowIndex, false);
5141                         }
5142
5143                         if (Rows.Count - e.RowCount <= 0) {
5144                                 MoveCurrentCell (-1, -1, true, false, false, true);
5145                                 hover_cell = null;
5146                         } else if (Columns.Count == 0) {
5147                                 MoveCurrentCell (-1, -1, true, false, false, true);
5148                                 hover_cell = null;
5149                         } else if (currentCell != null && currentCell.RowIndex == e.RowIndex) {
5150                                 int nextRowIndex = e.RowIndex;
5151                                 if (nextRowIndex >= Rows.Count - e.RowCount)
5152                                         nextRowIndex = Rows.Count - 1 - e.RowCount;
5153                                 MoveCurrentCell (currentCell != null ? currentCell.ColumnIndex : 0, nextRowIndex,
5154                                                  true, false, false, true);
5155                                 if (hover_cell != null && hover_cell.RowIndex >= e.RowIndex)
5156                                         hover_cell = null;
5157                         }
5158                 }
5159
5160                 internal void OnRowsPostRemovedInternal (DataGridViewRowsRemovedEventArgs e)
5161                 {
5162                         Invalidate ();
5163                         OnRowsRemoved (e);
5164                 }
5165
5166                 protected virtual void OnRowsRemoved (DataGridViewRowsRemovedEventArgs e)
5167                 {
5168                         DataGridViewRowsRemovedEventHandler eh = (DataGridViewRowsRemovedEventHandler)(Events [RowsRemovedEvent]);
5169                         if (eh != null) eh (this, e);
5170                 }
5171
5172                 protected internal virtual void OnRowStateChanged (int rowIndex, DataGridViewRowStateChangedEventArgs e)
5173                 {
5174                         DataGridViewRowStateChangedEventHandler eh = (DataGridViewRowStateChangedEventHandler)(Events [RowStateChangedEvent]);
5175                         if (eh != null) eh (this, e);
5176                 }
5177
5178                 protected virtual void OnRowUnshared (DataGridViewRowEventArgs e)
5179                 {
5180                         DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowUnsharedEvent]);
5181                         if (eh != null) eh (this, e);
5182                 }
5183
5184                 protected virtual void OnRowValidated (DataGridViewCellEventArgs e)
5185                 {
5186                         DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [RowValidatedEvent]);
5187                         if (eh != null) eh (this, e);
5188                 }
5189
5190                 protected virtual void OnRowValidating (DataGridViewCellCancelEventArgs e)
5191                 {
5192                         DataGridViewCellCancelEventHandler eh = (DataGridViewCellCancelEventHandler)(Events [RowValidatingEvent]);
5193                         if (eh != null) eh (this, e);
5194                 }
5195
5196                 protected virtual void OnScroll (ScrollEventArgs e)
5197                 {
5198                         ScrollEventHandler eh = (ScrollEventHandler)(Events [ScrollEvent]);
5199                         if (eh != null) eh (this, e);
5200                 }
5201
5202                 protected virtual void OnSelectionChanged (EventArgs e)
5203                 {
5204                         EventHandler eh = (EventHandler)(Events [SelectionChangedEvent]);
5205                         if (eh != null) eh (this, e);
5206                 }
5207
5208                 protected virtual void OnSortCompare (DataGridViewSortCompareEventArgs e) {
5209                         DataGridViewSortCompareEventHandler eh = (DataGridViewSortCompareEventHandler)(Events [SortCompareEvent]);
5210                         if (eh != null) eh (this, e);
5211                 }
5212
5213                 protected virtual void OnSorted (EventArgs e)
5214                 {
5215                         EventHandler eh = (EventHandler)(Events [SortedEvent]);
5216                         if (eh != null) eh (this, e);
5217                 }
5218
5219                 protected virtual void OnUserAddedRow (DataGridViewRowEventArgs e)
5220                 {
5221                         PrepareEditingRow (false, false);
5222
5223                         new_row_editing = true;
5224                         if (DataManager != null) {
5225                                 // Switch the current editing row with a real one
5226                                 if (editing_row != null) {
5227                                         Rows.RemoveInternal (editing_row);
5228                                         editing_row = null;
5229                                 }
5230                                 DataManager.AddNew (); // will raise OnListPositionChanged
5231                         }
5232
5233                         e = new DataGridViewRowEventArgs (Rows[NewRowIndex]);
5234                         DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [UserAddedRowEvent]);
5235                         if (eh != null) eh (this, e);
5236                 }
5237
5238                 protected virtual void OnUserDeletedRow (DataGridViewRowEventArgs e)
5239                 {
5240                         DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [UserDeletedRowEvent]);
5241                         if (eh != null) eh (this, e);
5242                 }
5243
5244                 protected virtual void OnUserDeletingRow (DataGridViewRowCancelEventArgs e)
5245                 {
5246                         DataGridViewRowCancelEventHandler eh = (DataGridViewRowCancelEventHandler)(Events [UserDeletingRowEvent]);
5247                         if (eh != null) eh (this, e);
5248                 }
5249
5250                 protected override void OnValidating (CancelEventArgs e)
5251                 {
5252                         base.OnValidating(e);
5253                 }
5254
5255                 protected override void OnVisibleChanged (EventArgs e)
5256                 {
5257                         base.OnVisibleChanged(e);
5258                 }
5259
5260                 protected virtual void PaintBackground (Graphics graphics, Rectangle clipBounds, Rectangle gridBounds)
5261                 {
5262                         graphics.FillRectangle (ThemeEngine.Current.ResPool.GetSolidBrush (backgroundColor), gridBounds);
5263                 }
5264
5265                 protected bool ProcessAKey (Keys keyData)
5266                 {
5267                         if (!MultiSelect)
5268                                 return false;
5269
5270                         if ((keyData & Keys.Control) == Keys.Control) {
5271                                 SelectAll ();
5272                                 return true;
5273                         }
5274
5275                         return false;
5276                 }
5277
5278                 protected virtual bool ProcessDataGridViewKey (KeyEventArgs e)
5279                 {
5280                         switch (e.KeyData & ~Keys.Modifiers) {
5281                                 case Keys.A:
5282                                         return ProcessAKey (e.KeyData);
5283                                 case Keys.Delete:
5284                                         return ProcessDeleteKey (e.KeyData);
5285                                 case Keys.Down:
5286                                         return ProcessDownKey (e.KeyData);
5287                                 case Keys.Escape:
5288                                         return ProcessEscapeKey (e.KeyData);
5289                                 case Keys.End:
5290                                         return ProcessEndKey (e.KeyData);
5291                                 case Keys.Enter:
5292                                         return ProcessEnterKey (e.KeyData);
5293                                 case Keys.F2:
5294                                         return ProcessF2Key (e.KeyData);
5295                                 case Keys.Home:
5296                                         return ProcessHomeKey (e.KeyData);
5297                                 case Keys.Left:
5298                                         return ProcessLeftKey (e.KeyData);
5299                                 case Keys.Next:
5300                                         return ProcessNextKey (e.KeyData);
5301                                 case Keys.Prior:
5302                                         return ProcessPriorKey (e.KeyData);
5303                                 case Keys.Right:
5304                                         return ProcessRightKey (e.KeyData);
5305                                 case Keys.Space:
5306                                         return ProcessSpaceKey (e.KeyData);
5307                                 case Keys.Tab:
5308                                         return ProcessTabKey (e.KeyData);
5309                                 case Keys.Up:
5310                                         return ProcessUpKey (e.KeyData);
5311                                 case Keys.D0:
5312                                 case Keys.NumPad0:
5313                                         return ProcessZeroKey (e.KeyData);
5314                         }
5315
5316                         return false;
5317                 }
5318
5319                 protected bool ProcessDeleteKey (Keys keyData)
5320                 {
5321                         if (!AllowUserToDeleteRows || SelectedRows.Count == 0)
5322                                 return false;
5323
5324                         for (int i = SelectedRows.Count - 1; i >= 0; i--) {
5325                                 DataGridViewRow row = SelectedRows[i];
5326
5327                                 if (row.IsNewRow)
5328                                         continue;
5329
5330                                 if (hover_cell != null && hover_cell.OwningRow == row)
5331                                         hover_cell = null;
5332
5333                                 if (DataManager != null)
5334                                         DataManager.RemoveAt (row.Index);
5335                                 else
5336                                         Rows.RemoveAt (row.Index);
5337                         }
5338
5339                         return true;
5340                 }
5341
5342                 protected override bool ProcessDialogKey (Keys keyData)
5343                 {
5344                         switch (keyData) {
5345                                 case Keys.Tab:
5346                                 case Keys.Shift | Keys.Tab:
5347                                         if (standardTab)
5348                                                 return base.ProcessDialogKey (keyData & ~Keys.Control);
5349
5350                                         if (ProcessDataGridViewKey (new KeyEventArgs (keyData)))
5351                                                 return true;
5352
5353                                         break;
5354                                 case Keys.Control | Keys.Tab:
5355                                 case Keys.Control | Keys.Shift | Keys.Tab:
5356                                         if (!standardTab)
5357                                                 return base.ProcessDialogKey (keyData & ~Keys.Control);
5358
5359                                         if (ProcessDataGridViewKey (new KeyEventArgs (keyData)))
5360                                                 return true;
5361
5362                                         break;
5363                                 case Keys.Enter:
5364                                 case Keys.Escape:
5365                                         if (ProcessDataGridViewKey (new KeyEventArgs (keyData)))
5366                                                 return true;
5367
5368                                         break;
5369                         }
5370
5371                         return base.ProcessDialogKey(keyData);
5372                 }
5373
5374                 protected bool ProcessDownKey (Keys keyData)
5375                 {
5376                         int current_row = CurrentCellAddress.Y;
5377
5378                         if (current_row < Rows.Count - 1) {
5379                                 // Move to the last cell in the column
5380                                 if ((keyData & Keys.Control) == Keys.Control)
5381                                         MoveCurrentCell (CurrentCellAddress.X, Rows.Count - 1, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5382                                 // Move one cell down
5383                                 else
5384                                         MoveCurrentCell (CurrentCellAddress.X, current_row + 1, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5385
5386                                 return true;
5387                         }
5388
5389                         return false;
5390                 }
5391
5392                 protected bool ProcessEndKey (Keys keyData)
5393                 {
5394                         int disp_index = ColumnIndexToDisplayIndex (currentCellAddress.X);
5395
5396                         // Move to the last cell in the control
5397                         if ((keyData & Keys.Control) == Keys.Control) {
5398                                 MoveCurrentCell (ColumnDisplayIndexToIndex (Columns.Count - 1), Rows.Count - 1, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5399                                 return true;
5400                         }
5401
5402                         // Move to the last cell in the row
5403                         if (disp_index < Columns.Count - 1) {
5404                                 MoveCurrentCell (ColumnDisplayIndexToIndex (Columns.Count - 1), currentCellAddress.Y, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5405                                 return true;
5406                         }
5407
5408                         return false;
5409                 }
5410
5411                 protected bool ProcessEnterKey (Keys keyData)
5412                 {
5413                         if (ProcessDownKey (keyData))
5414                                 return true;
5415
5416                         // ProcessDown may fail if we are on the last row,
5417                         // but Enter should still EndEdit if this is the last row
5418                         EndEdit ();
5419                         return true;
5420                 }
5421
5422                 protected bool ProcessEscapeKey (Keys keyData)
5423                 {
5424                         if (!IsCurrentCellInEditMode)
5425                                 return false;
5426
5427                         CancelEdit ();
5428                         return true;
5429                 }
5430
5431                 protected bool ProcessF2Key (Keys keyData)
5432                 {
5433                         if (editMode == DataGridViewEditMode.EditOnF2 || editMode == DataGridViewEditMode.EditOnKeystrokeOrF2) {
5434                                 BeginEdit (true);
5435                                 return true;
5436                         }
5437
5438                         return false;
5439                 }
5440
5441                 protected bool ProcessHomeKey (Keys keyData)
5442                 {
5443                         int disp_index = ColumnIndexToDisplayIndex (currentCellAddress.X);
5444
5445                         // Move to the first cell in the control
5446                         if ((keyData & Keys.Control) == Keys.Control) {
5447                                 MoveCurrentCell (ColumnDisplayIndexToIndex (0), 0, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5448                                 return true;
5449                         }
5450
5451                         // Move to the first cell in the row
5452                         if (disp_index > 0) {
5453                                 MoveCurrentCell (ColumnDisplayIndexToIndex (0), currentCellAddress.Y, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5454                                 return true;
5455                         }
5456
5457                         return false;
5458                 }
5459
5460                 [MonoInternalNote ("What does insert do?")]
5461                 protected bool ProcessInsertKey (Keys keyData)
5462                 {
5463                         return false;
5464                 }
5465
5466                 protected override bool ProcessKeyEventArgs (ref Message m)
5467                 {
5468                         DataGridViewCell cell = CurrentCell;
5469
5470                         if (cell != null) {
5471                                 if (cell.KeyEntersEditMode (new KeyEventArgs (((Keys)m.WParam.ToInt32 ()) | XplatUI.State.ModifierKeys)))
5472                                         BeginEdit (true);
5473                                 if (EditingControl != null && ((Msg)m.Msg == Msg.WM_KEYDOWN || (Msg)m.Msg == Msg.WM_CHAR))
5474                                         XplatUI.SendMessage (EditingControl.Handle, (Msg)m.Msg, m.WParam, m.LParam);
5475                         }
5476
5477                         return base.ProcessKeyEventArgs (ref m);
5478                 }
5479
5480                 protected override bool ProcessKeyPreview (ref Message m)
5481                 {
5482                         if ((Msg)m.Msg == Msg.WM_KEYDOWN && (IsCurrentCellInEditMode || m.HWnd == horizontalScrollBar.Handle || m.HWnd == verticalScrollBar.Handle)) {
5483                                 KeyEventArgs e = new KeyEventArgs (((Keys)m.WParam.ToInt32 ()) | XplatUI.State.ModifierKeys);
5484
5485                                 IDataGridViewEditingControl ctrl = (IDataGridViewEditingControl)EditingControlInternal;
5486
5487                                 if (ctrl != null)
5488                                         if (ctrl.EditingControlWantsInputKey (e.KeyData, false))
5489                                                 return false;
5490
5491                                 switch (e.KeyData) {
5492                                         case Keys.Escape:
5493                                         case Keys.Down:
5494                                         case Keys.Up:
5495                                         case Keys.Left:
5496                                         case Keys.Right:
5497                                         case Keys.Tab:
5498                                         case Keys.Prior:
5499                                         case Keys.Next:
5500                                                 return ProcessDataGridViewKey (e);
5501                                 }
5502                         }
5503
5504                         return base.ProcessKeyPreview (ref m);
5505                 }
5506
5507                 protected bool ProcessLeftKey (Keys keyData)
5508                 {
5509                         int disp_index = ColumnIndexToDisplayIndex (currentCellAddress.X);
5510
5511                         if (disp_index > 0) {
5512                                 // Move to the first cell in the row
5513                                 if ((keyData & Keys.Control) == Keys.Control)
5514                                         MoveCurrentCell (ColumnDisplayIndexToIndex (0), currentCellAddress.Y, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5515                                 // Move one cell to the left
5516                                 else
5517                                         MoveCurrentCell (ColumnDisplayIndexToIndex (disp_index - 1), currentCellAddress.Y, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5518
5519                                 return true;
5520                         }
5521
5522                         return false;
5523                 }
5524
5525                 // Page Down
5526                 protected bool ProcessNextKey (Keys keyData)
5527                 {
5528                         int current_row = CurrentCellAddress.Y;
5529
5530                         if (current_row < Rows.Count - 1) {
5531                                 // Move one "page" of cells down
5532                                 int new_row = Math.Min (Rows.Count - 1, current_row + DisplayedRowCount (false));
5533
5534                                 MoveCurrentCell (CurrentCellAddress.X, new_row, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5535
5536                                 return true;
5537                         }
5538
5539                         return false;
5540                 }
5541
5542                 // Page Up
5543                 protected bool ProcessPriorKey (Keys keyData)
5544                 {
5545                         int current_row = CurrentCellAddress.Y;
5546
5547                         if (current_row > 0) {
5548                                 // Move one "page" of cells up
5549                                 int new_row = Math.Max (0, current_row - DisplayedRowCount (false));
5550
5551                                 MoveCurrentCell (CurrentCellAddress.X, new_row, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5552
5553                                 return true;
5554                         }
5555
5556                         return false;
5557                 }
5558
5559                 protected bool ProcessRightKey (Keys keyData)
5560                 {
5561                         int disp_index = ColumnIndexToDisplayIndex (currentCellAddress.X);
5562
5563                         if (disp_index < Columns.Count - 1) {
5564                                 // Move to the last cell in the row
5565                                 if ((keyData & Keys.Control) == Keys.Control)
5566                                         MoveCurrentCell (ColumnDisplayIndexToIndex (Columns.Count - 1), currentCellAddress.Y, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5567                                 // Move one cell to the right
5568                                 else
5569                                         MoveCurrentCell (ColumnDisplayIndexToIndex (disp_index + 1), currentCellAddress.Y, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5570
5571                                 return true;
5572                         }
5573
5574                         return false;
5575                 }
5576
5577                 protected bool ProcessSpaceKey (Keys keyData)
5578                 {
5579                         if ((keyData & Keys.Shift) == Keys.Shift) {
5580                                 if (selectionMode == DataGridViewSelectionMode.RowHeaderSelect) {
5581                                         SetSelectedRowCore (CurrentCellAddress.Y, true);
5582                                         InvalidateRow (CurrentCellAddress.Y);
5583                                         return true;
5584                                 }
5585                                 if (selectionMode == DataGridViewSelectionMode.ColumnHeaderSelect) {
5586                                         SetSelectedColumnCore (CurrentCellAddress.X, true);
5587                                         InvalidateColumn (CurrentCellAddress.X);
5588                                         return true;
5589                                 }
5590                         }
5591
5592                         if (CurrentCell is DataGridViewButtonCell || CurrentCell is DataGridViewLinkCell || CurrentCell is DataGridViewCheckBoxCell) {
5593                                 DataGridViewCellEventArgs e = new DataGridViewCellEventArgs (CurrentCell.ColumnIndex, CurrentCell.RowIndex);
5594
5595                                 OnCellClick (e);
5596                                 OnCellContentClick (e);
5597
5598                                 if (CurrentCell is DataGridViewButtonCell)
5599                                         (CurrentCell as DataGridViewButtonCell).OnClickInternal (e);
5600                                 if (CurrentCell is DataGridViewCheckBoxCell)
5601                                         (CurrentCell as DataGridViewCheckBoxCell).OnClickInternal (e);
5602
5603                                 return true;
5604                         }
5605
5606                         return false;
5607                 }
5608
5609                 protected bool ProcessTabKey (Keys keyData)
5610                 {
5611                         Form f = FindForm ();
5612
5613                         if (f != null)
5614                                 f.ActivateFocusCues ();
5615
5616                         int disp_index = ColumnIndexToDisplayIndex (currentCellAddress.X);
5617
5618                         // Tab goes forward
5619                         // Shift-tab goes backwards
5620                         if ((keyData & Keys.Shift) == Keys.Shift) {
5621                                 if (disp_index > 0) {
5622                                         // Move one cell to the left
5623                                         MoveCurrentCell (ColumnDisplayIndexToIndex (disp_index - 1), currentCellAddress.Y, true, (keyData & Keys.Control) == Keys.Control, false, true);
5624                                         return true;
5625                                 } else if (currentCellAddress.Y > 0) {
5626                                         // Move to the last cell in the previous row
5627                                         MoveCurrentCell (ColumnDisplayIndexToIndex (Columns.Count - 1), currentCellAddress.Y - 1, true, false, false, true);
5628                                         return true;
5629                                 }
5630
5631                         } else {
5632                                 if (disp_index < Columns.Count - 1) {
5633                                         // Move one cell to the right
5634                                         MoveCurrentCell (ColumnDisplayIndexToIndex (disp_index + 1), currentCellAddress.Y, true, (keyData & Keys.Control) == Keys.Control, false, true);
5635
5636                                         return true;
5637                                 } else if (currentCellAddress.Y < Rows.Count - 1) {
5638                                         // Move to the first cell in the next row
5639                                         MoveCurrentCell (ColumnDisplayIndexToIndex (0), currentCellAddress.Y + 1, true, false, false, true);
5640                                         return true;
5641                                 }
5642
5643
5644                         }
5645
5646                         return false;
5647                 }
5648
5649                 protected bool ProcessUpKey (Keys keyData)
5650                 {
5651                         int current_row = CurrentCellAddress.Y;
5652
5653                         if (current_row > 0) {
5654                                 // Move to the first cell in the column
5655                                 if ((keyData & Keys.Control) == Keys.Control)
5656                                         MoveCurrentCell (CurrentCellAddress.X, 0, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5657                                 // Move one cell up
5658                                 else
5659                                         MoveCurrentCell (CurrentCellAddress.X, current_row - 1, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5660
5661                                 return true;
5662                         }
5663
5664                         return false;
5665                 }
5666
5667                 protected bool ProcessZeroKey (Keys keyData)
5668                 {
5669                         if ((keyData & Keys.Control) == Keys.Control && CurrentCell.EditType != null) {
5670                                 CurrentCell.Value = DBNull.Value;
5671                                 InvalidateCell (CurrentCell);
5672                                 return true;
5673                         }
5674
5675                         return false;
5676                 }
5677
5678                 protected override void SetBoundsCore (int x, int y, int width, int height, BoundsSpecified specified) {
5679                         base.SetBoundsCore(x, y, width, height, specified);
5680                 }
5681
5682                 [MonoTODO ("Does not use validateCurrentCell")]
5683                 protected virtual bool SetCurrentCellAddressCore (int columnIndex, int rowIndex, bool setAnchorCellAddress, bool validateCurrentCell, bool throughMouseClick)
5684                 {
5685                         if ((columnIndex < 0 || columnIndex > Columns.Count - 1) && rowIndex != -1)
5686                                 throw new ArgumentOutOfRangeException ("columnIndex");
5687                         if ((rowIndex < 0 || rowIndex > Rows.Count - 1) && columnIndex != -1)
5688                                 throw new ArgumentOutOfRangeException ("rowIndex");
5689
5690                         DataGridViewCell cell;
5691
5692                         if (columnIndex == -1 && rowIndex == -1)
5693                                 cell = null;
5694                         else
5695                                 cell = Rows.SharedRow (rowIndex).Cells[columnIndex];
5696
5697                         if (cell != null && !cell.Visible)
5698                                 throw new InvalidOperationException ("cell is not visible");
5699
5700                         // Always update the current cell address property
5701                         // If the row has moved it would be out of date.
5702                         if (currentCell != null) {
5703                                 if (setAnchorCellAddress) {
5704                                         anchor_cell.X = currentCell.ColumnIndex;
5705                                         anchor_cell.Y = currentCell.RowIndex;
5706                                 }
5707                                 currentCellAddress.X = currentCell.ColumnIndex;
5708                                 currentCellAddress.Y = currentCell.RowIndex;
5709                         }
5710
5711                         if (cell != currentCell) {
5712                                 if (currentCell != null) {
5713                                         if (currentCell.IsInEditMode) {
5714                                                 if (!EndEdit ())
5715                                                         return false;
5716                                                 else if (currentCell.RowIndex == NewRowIndex && new_row_editing)
5717                                                         CancelEdit ();
5718                                         } else {
5719                                                 // CancelEdit will replace the uncommited real editing row with a place holder row
5720                                                 if (new_row_editing && currentCell.RowIndex == NewRowIndex)
5721                                                         CancelEdit ();
5722                                         }
5723                                         OnCellLeave (new DataGridViewCellEventArgs(currentCell.ColumnIndex, currentCell.RowIndex));
5724                                         OnRowLeave (new DataGridViewCellEventArgs (currentCell.ColumnIndex, currentCell.RowIndex));
5725                                 }
5726
5727                                 currentCell = cell;
5728                                 if (setAnchorCellAddress)
5729                                         anchor_cell = new Point (columnIndex, rowIndex);
5730                                 currentCellAddress = new Point (columnIndex, rowIndex);
5731
5732                                 if (cell != null) {
5733                                         UpdateBindingPosition (cell.RowIndex);
5734                                         OnRowEnter (new DataGridViewCellEventArgs (cell.ColumnIndex, cell.RowIndex));
5735                                         OnCellEnter (new DataGridViewCellEventArgs(cell.ColumnIndex, cell.RowIndex));
5736                                 }
5737                                 OnCurrentCellChanged (EventArgs.Empty);
5738
5739                                 if (cell != null) {
5740                                         // If the user begins an edit in the NewRow, add a new real row
5741                                         if (AllowUserToAddRows && cell.RowIndex == NewRowIndex && !is_binding && !new_row_editing) {
5742                                                 // OnUserAddedRow will add a real row and reset the current cell
5743                                                 OnUserAddedRow (new DataGridViewRowEventArgs (Rows[NewRowIndex]));
5744                                         } else {
5745                                                 if (editMode == DataGridViewEditMode.EditOnEnter)
5746                                                         BeginEdit (true);
5747                                         }
5748                                 }
5749                         } else {
5750                                 if (cell != null && throughMouseClick)
5751                                         BeginEdit (true);
5752                         }
5753
5754                         return true;
5755                 }
5756
5757                 protected virtual void SetSelectedCellCore (int columnIndex, int rowIndex, bool selected) {
5758                         rows [rowIndex].Cells [columnIndex].Selected = selected;
5759
5760                         OnSelectionChanged (EventArgs.Empty);
5761                 }
5762
5763                 internal void SetSelectedColumnCoreInternal (int columnIndex, bool selected) {
5764                         SetSelectedColumnCore (columnIndex, selected);
5765                 }
5766
5767                 protected virtual void SetSelectedColumnCore (int columnIndex, bool selected) {
5768                         if (selectionMode != DataGridViewSelectionMode.ColumnHeaderSelect && selectionMode != DataGridViewSelectionMode.FullColumnSelect)
5769                                 return;
5770
5771                         DataGridViewColumn col = columns [columnIndex];
5772
5773                         col.SelectedInternal = selected;
5774
5775                         if (selected_columns == null)
5776                                 selected_columns = new DataGridViewSelectedColumnCollection ();
5777
5778                         bool selectionChanged = false;
5779                         if (!selected && selected_columns.Contains (col)) {
5780                                 selected_columns.InternalRemove (col);
5781                                 selectionChanged = true;
5782                         } else if (selected && !selected_columns.Contains (col)) {
5783                                 selected_columns.InternalAdd (col);
5784                                 selectionChanged = true;
5785                         }
5786
5787                         if (selectionChanged)
5788                                 OnSelectionChanged (EventArgs.Empty);
5789
5790                         Invalidate();
5791                 }
5792
5793                 internal void SetSelectedRowCoreInternal (int rowIndex, bool selected) {
5794                         if (rowIndex >= 0 && rowIndex < Rows.Count)
5795                                 SetSelectedRowCore (rowIndex, selected);
5796                 }
5797
5798                 protected virtual void SetSelectedRowCore (int rowIndex, bool selected) {
5799                         DataGridViewRow row = rows [rowIndex];
5800
5801                         row.SelectedInternal = selected;
5802
5803                         if (selected_rows == null)
5804                                 selected_rows = new DataGridViewSelectedRowCollection (this);
5805
5806                         bool selectionChanged = false;
5807                         if (!selected && selected_rows.Contains (row)) {
5808                                 selected_rows.InternalRemove (row);
5809                                 selectionChanged = true;
5810                         } else if (selected && !selected_rows.Contains (row)) {
5811                                 selected_rows.InternalAdd (row);
5812                                 selectionChanged = true;
5813                         }
5814
5815                         if (selectionChanged)
5816                                 OnSelectionChanged (EventArgs.Empty);
5817
5818                         Invalidate();
5819                 }
5820
5821                 protected override void WndProc (ref Message m)
5822                 {
5823                         base.WndProc (ref m);
5824                 }
5825
5826                 internal void InternalOnCellClick (DataGridViewCellEventArgs e)
5827                 {
5828                         OnCellClick (e);
5829                 }
5830
5831                 internal void InternalOnCellContentClick (DataGridViewCellEventArgs e)
5832                 {
5833                         OnCellContentClick (e);
5834                 }
5835
5836                 internal void InternalOnCellContentDoubleClick (DataGridViewCellEventArgs e)
5837                 {
5838                         OnCellContentDoubleClick (e);
5839                 }
5840
5841                 internal void InternalOnCellValueChanged (DataGridViewCellEventArgs e)
5842                 {
5843                         OnCellValueChanged (e);
5844                 }
5845
5846                 internal void InternalOnDataError (DataGridViewDataErrorEventArgs e)
5847                 {
5848                         /////////////// false? ////////////
5849                         OnDataError (false, e);
5850                 }
5851
5852                 internal void InternalOnMouseWheel (MouseEventArgs e)
5853                 {
5854                         OnMouseWheel (e);
5855                 }
5856
5857                 internal void OnHScrollBarScroll (object sender, ScrollEventArgs e)
5858                 {
5859                         int lastRightVisibleColumntIndex = Columns.Count - DisplayedColumnCount (false);
5860                         horizontalScrollingOffset = e.NewValue;
5861                         int left = 0;
5862
5863                         for (int index = 0; index < Columns.Count; index++) {
5864                                 DataGridViewColumn col = Columns[index];
5865
5866                                 if (col.Index >= lastRightVisibleColumntIndex) {
5867                                         first_col_index = lastRightVisibleColumntIndex;
5868                                         Invalidate ();
5869                                         OnScroll (e);
5870                                 } else if (e.NewValue < left + col.Width) {
5871                                         if (first_col_index != index) {
5872                                                 first_col_index = index;
5873                                                 Invalidate ();
5874                                                 OnScroll (e);
5875                                         }
5876
5877                                         return;
5878                                 }
5879
5880                                 left += col.Width;
5881                         }
5882                 }
5883
5884                 internal void OnVScrollBarScroll (object sender, ScrollEventArgs e)
5885                 {
5886                         verticalScrollingOffset = e.NewValue;
5887                         if (Rows.Count == 0)
5888                                 return;
5889
5890                         int top = 0;
5891                         int lastTopVisibleRowIndex = Rows.Count - DisplayedRowCount (false);
5892
5893                         for (int index = 0; index < Rows.Count; index++) {
5894                                 DataGridViewRow row = Rows[index];
5895                                 if (!row.Visible)
5896                                         continue;
5897
5898                                 if (row.Index >= lastTopVisibleRowIndex) {
5899                                         first_row_index = lastTopVisibleRowIndex;
5900                                         Invalidate ();
5901                                         OnScroll (e);
5902                                 } else if (e.NewValue < top + row.Height) {
5903                                         if (first_row_index != index) {
5904                                                 first_row_index = index;
5905                                                 Invalidate ();
5906                                                 OnScroll (e);
5907                                         }
5908
5909                                         return;
5910                                 }
5911
5912                                 top += row.Height;
5913                         }
5914
5915                         first_row_index = lastTopVisibleRowIndex;
5916                         Invalidate ();
5917                         OnScroll (e);
5918                 }
5919
5920                 internal void RaiseCellStyleChanged (DataGridViewCellEventArgs e) {
5921                         OnCellStyleChanged(e);
5922                 }
5923
5924                 internal void OnColumnCollectionChanged (object sender, CollectionChangeEventArgs e) {
5925                         switch (e.Action) {
5926                                 case CollectionChangeAction.Add:
5927                                         OnColumnAddedInternal(new DataGridViewColumnEventArgs(e.Element as DataGridViewColumn));
5928                                         break;
5929                                 case CollectionChangeAction.Remove:
5930                                         OnColumnPostRemovedInternal(new DataGridViewColumnEventArgs(e.Element as DataGridViewColumn));
5931                                         break;
5932                                 case CollectionChangeAction.Refresh:
5933                                         hover_cell = null;
5934                                         MoveCurrentCell (-1, -1, true, false, false, true);
5935                                         break;
5936                         }
5937                 }
5938
5939                 // Resizes all columns according to their AutoResizeMode property.
5940                 // First all the columns that aren't Filled are resized, then we resize all the Filled columns.
5941                 internal void AutoResizeColumnsInternal ()
5942                 {
5943                         for (int i = 0; i < Columns.Count; i++)
5944                                 AutoResizeColumnInternal (i, Columns [i].InheritedAutoSizeMode);
5945
5946                         AutoFillColumnsInternal ();
5947                 }
5948
5949                 internal void AutoFillColumnsInternal ()
5950                 {
5951                         float totalFillWeight = 0;
5952                         int FillCount = 0; // The number of columns that has AutoSizeMode.Fill set
5953                         int spaceLeft = ClientSize.Width - (verticalScrollBar.VisibleInternal ? verticalScrollBar.Width : 0);
5954
5955                         if (RowHeadersVisible) {
5956                                 spaceLeft -= RowHeadersWidth;
5957                         }
5958                         spaceLeft -= BorderWidth * 2;
5959
5960                         int [] fixed_widths = new int [Columns.Count];
5961                         int [] new_widths = new int [Columns.Count];
5962                         bool fixed_any = false;
5963
5964                         for (int i = 0; i < Columns.Count; i++) {
5965                                 DataGridViewColumn col = Columns [i];
5966
5967                                 if (!col.Visible)
5968                                         continue;
5969
5970                                 switch (col.InheritedAutoSizeMode) {
5971                                 case DataGridViewAutoSizeColumnMode.Fill:
5972                                         FillCount++;
5973                                         totalFillWeight += col.FillWeight;
5974                                         break;
5975                                 case DataGridViewAutoSizeColumnMode.AllCellsExceptHeader:
5976                                 case DataGridViewAutoSizeColumnMode.AllCells:
5977                                 case DataGridViewAutoSizeColumnMode.DisplayedCells:
5978                                 case DataGridViewAutoSizeColumnMode.DisplayedCellsExceptHeader:
5979                                 case DataGridViewAutoSizeColumnMode.None:
5980                                 case DataGridViewAutoSizeColumnMode.NotSet:
5981                                         spaceLeft -= Columns [i].Width;
5982                                         break;
5983                                 }
5984                         }
5985
5986                         spaceLeft = Math.Max (0, spaceLeft);
5987
5988                         do {
5989                                 fixed_any = false;
5990                                 for (int i = 0; i < columns.Count; i++) {
5991                                         DataGridViewColumn col = Columns [i];
5992                                         int width;
5993
5994                                         if (col.InheritedAutoSizeMode != DataGridViewAutoSizeColumnMode.Fill)
5995                                                 continue;
5996
5997                                         if (!col.Visible)
5998                                                 continue;
5999
6000                                         if (fixed_widths [i] != 0)
6001                                                 continue;
6002
6003                                         width = (totalFillWeight == 0) ? 0 : (int) Math.Round (spaceLeft * (col.FillWeight / totalFillWeight), 0);
6004
6005                                         if (width < 0)
6006                                                 width = 0;
6007
6008                                         if (width < col.MinimumWidth) {
6009                                                 width = col.MinimumWidth;
6010                                                 fixed_widths [i] = width;
6011                                                 fixed_any = true;
6012                                                 spaceLeft -= width;
6013                                                 totalFillWeight -= col.FillWeight;
6014                                         }
6015
6016                                         new_widths [i] = width;
6017                                 }
6018                         } while (fixed_any);
6019
6020                         for (int i = 0; i < columns.Count; i++) {
6021                                 if (Columns [i].InheritedAutoSizeMode != DataGridViewAutoSizeColumnMode.Fill)
6022                                         continue;
6023
6024                                 if (!Columns[i].Visible)
6025                                         continue;
6026
6027                                 Columns [i].Width = new_widths [i];
6028                         }
6029                 }
6030
6031                 internal void AutoResizeColumnInternal (int columnIndex, DataGridViewAutoSizeColumnMode mode)
6032                 {
6033                         // http://msdn2.microsoft.com/en-us/library/ms171605.aspx
6034                         int size = 0;
6035
6036                         DataGridViewColumn col = Columns [columnIndex];
6037
6038                         switch (mode) {
6039                         case DataGridViewAutoSizeColumnMode.Fill:
6040                                 return;
6041                         case DataGridViewAutoSizeColumnMode.AllCellsExceptHeader:
6042                         case DataGridViewAutoSizeColumnMode.AllCells:
6043                         case DataGridViewAutoSizeColumnMode.DisplayedCells:
6044                         case DataGridViewAutoSizeColumnMode.DisplayedCellsExceptHeader:
6045                                 size  = Math.Max (CalculateColumnCellWidth (columnIndex, col.InheritedAutoSizeMode),
6046                                                   col.HeaderCell.ContentBounds.Width);
6047                                 break;
6048                         case DataGridViewAutoSizeColumnMode.ColumnHeader:
6049                                 size = col.HeaderCell.ContentBounds.Width;
6050                                 break;
6051                         default:
6052                                 size = col.Width;
6053                                 break;
6054                         }
6055
6056                         if (size < 0)
6057                                 size = 0;
6058                         if (size < col.MinimumWidth)
6059                                 size = col.MinimumWidth;
6060
6061                         col.Width = size;
6062                 }
6063
6064                 internal int CalculateColumnCellWidth (int index, DataGridViewAutoSizeColumnMode mode)
6065                 {
6066                         int first_row = 0;
6067                         int last_row = Rows.Count;
6068                         int result = 0;
6069
6070                         if (mode == DataGridViewAutoSizeColumnMode.DisplayedCells ||
6071                             mode == DataGridViewAutoSizeColumnMode.DisplayedCellsExceptHeader) {
6072                                 first_row = first_row_index;
6073                                 last_row = DisplayedRowCount (true);;
6074                         }
6075
6076                         for (int i = first_row; i < last_row; i++) {
6077                                 if (!Rows[i].Visible)
6078                                         continue;
6079
6080                                 int cell_width = Rows[i].Cells[index].PreferredSize.Width;
6081                                 result = Math.Max (result, cell_width);
6082                         }
6083
6084                         return result;
6085                 }
6086
6087                 Rectangle GetHeaderCellBounds (DataGridViewHeaderCell cell)
6088                 {
6089                         Rectangle bounds = new Rectangle (ClientRectangle.Location, cell.Size);
6090                         if (cell is DataGridViewColumnHeaderCell) {
6091                                 if (RowHeadersVisible)
6092                                         bounds.X += RowHeadersWidth;
6093                                 List<DataGridViewColumn> sortedColumns = columns.ColumnDisplayIndexSortedArrayList;
6094                                 for (int index = first_col_index; index < sortedColumns.Count; index++) {
6095                                         DataGridViewColumn column = sortedColumns [index];
6096                                         if (column.Index == cell.ColumnIndex)
6097                                                 break;
6098                                         bounds.X += column.Width;
6099                                 }
6100                         } else {
6101                                 if (ColumnHeadersVisible)
6102                                         bounds.Y += ColumnHeadersHeight;
6103                                 for (int index = first_row_index; index < Rows.Count; index++) {
6104                                         DataGridViewRow row = GetRowInternal (index);
6105                                         if (row.HeaderCell == cell)
6106                                                 break;
6107                                         bounds.Y += row.Height;
6108                                 }
6109                         }
6110                         return bounds;
6111                 }
6112
6113                 private void PrepareEditingRow (bool cell_changed, bool column_changed)
6114                 {
6115                         if (new_row_editing)
6116                                 return;
6117
6118                         bool show = false;
6119
6120                         show = ColumnCount > 0 && AllowUserToAddRows;
6121
6122                         if (!show) {
6123                                 RemoveEditingRow ();
6124                         } else if (show) {
6125                                 if (editing_row != null && (cell_changed || column_changed)) {
6126                                         // The row changed, it's no longer an editing row.
6127                                         //    or
6128                                         // The number of columns has changed, we need a new editing row.
6129                                         RemoveEditingRow ();
6130                                 }
6131                                 if (editing_row == null) {
6132                                         editing_row = RowTemplateFull;
6133                                         Rows.AddInternal (editing_row, false);
6134                                 }
6135                         }
6136                 }
6137
6138                 internal void RemoveEditingRow ()
6139                 {
6140                         if (editing_row != null) {
6141                                 if (Rows.Contains (editing_row))
6142                                     Rows.RemoveInternal (editing_row);
6143                                 editing_row = null;
6144                         }
6145                 }
6146
6147                 internal DataGridViewRow EditingRow {
6148                         get { return editing_row; }
6149                 }
6150
6151                 private void AddBoundRow (object element)
6152                 {
6153                         // Don't add rows if there are no columns
6154                         if (ColumnCount == 0)
6155                                 return;
6156
6157                         DataGridViewRow row = (DataGridViewRow)RowTemplateFull;
6158                         rows.AddInternal (row, false);
6159                 }
6160
6161                 private bool IsColumnAlreadyBound (string name)
6162                 {
6163                         foreach (DataGridViewColumn col in Columns)
6164                                 if (String.Compare (col.DataPropertyName, name, true) == 0)
6165                                         return true;
6166
6167                         return false;
6168                 }
6169
6170                 private DataGridViewColumn CreateColumnByType (Type type)
6171                 {
6172                         if (type == typeof (bool))
6173                                 return new DataGridViewCheckBoxColumn ();
6174                         else if (typeof(Bitmap).IsAssignableFrom (type))
6175                                 return new DataGridViewImageColumn ();
6176
6177                         return new DataGridViewTextBoxColumn ();
6178                 }
6179
6180                 private void ClearBinding ()
6181                 {
6182                         if (IsCurrentCellInEditMode && !EndEdit ())
6183                                 CancelEdit ();
6184                         MoveCurrentCell (-1, -1, false, false, false, true);
6185
6186                         if (DataManager != null) {
6187                                 DataManager.ListChanged -= OnListChanged;
6188                                 DataManager.PositionChanged -= OnListPositionChanged;
6189                                 columns.ClearAutoGeneratedColumns ();
6190                                 rows.Clear ();
6191                                 RemoveEditingRow ();
6192                         }
6193                 }
6194
6195                 private void ResetRows ()
6196                 {
6197                         rows.Clear ();
6198                         RemoveEditingRow ();
6199                         if (DataManager != null) {
6200                                 foreach (object element in DataManager.List)
6201                                         AddBoundRow (element);
6202                         }
6203                         PrepareEditingRow (false, true);
6204                         OnListPositionChanged (this, EventArgs.Empty);
6205                 }
6206
6207                 private void DoBinding ()
6208                 {
6209                         /* The System.Windows.Forms.DataGridView class supports the standard Windows Forms data-binding model. This means the data source can be of any type that implements:
6210                          - the System.Collections.IList interface, including one-dimensional arrays.
6211                          - the System.ComponentModel.IListSource interface, such as the System.Data.DataTable and System.Data.DataSet classes.
6212                          - the System.ComponentModel.IBindingList interface, such as the System.ComponentModel.Collections.BindingList<> class.
6213                          - the System.ComponentModel.IBindingListView interface, such as the System.Windows.Forms.BindingSource class.
6214                         */
6215
6216                         if (dataSource != null && DataManager != null) {
6217                                 if (autoGenerateColumns) {
6218                                         is_autogenerating_columns = true;
6219
6220                                         foreach (PropertyDescriptor property in DataManager.GetItemProperties()) {
6221                                                 // This keeps out things like arrays
6222                                                 if ((typeof(ICollection).IsAssignableFrom (property.PropertyType)))
6223                                                         continue;
6224                                                 if (!property.IsBrowsable)
6225                                                         continue;
6226
6227                                                 if (IsColumnAlreadyBound (property.Name))
6228                                                         continue;
6229
6230                                                 DataGridViewColumn col = CreateColumnByType (property.PropertyType);
6231                                                 col.Name = property.DisplayName;
6232                                                 col.DataPropertyName = property.Name;
6233                                                 col.ReadOnly = !DataManager.AllowEdit || property.IsReadOnly;
6234                                                 col.ValueType = property.PropertyType;
6235                                                 col.AutoGenerated = true;
6236                                                 columns.Add (col);
6237                                         }
6238
6239                                         is_autogenerating_columns = false;
6240                                 }
6241
6242                                 // DataBind both autogenerated and not columns if there is a matching property
6243                                 foreach (DataGridViewColumn column in columns)
6244                                         column.DataColumnIndex = FindDataColumnIndex (column);
6245
6246                                 foreach (object element in DataManager.List)
6247                                         AddBoundRow (element);
6248
6249                                 DataManager.ListChanged += OnListChanged;
6250                                 DataManager.PositionChanged += OnListPositionChanged;
6251                                 OnDataBindingComplete (new DataGridViewBindingCompleteEventArgs (ListChangedType.Reset));
6252                                 OnListPositionChanged (this, EventArgs.Empty);
6253                         } else {
6254                                 if (Rows.Count > 0 && Columns.Count > 0)
6255                                         MoveCurrentCell (0, 0, true, false, false, false);
6256                         }
6257
6258                         PrepareEditingRow (false, true);
6259                 }
6260
6261                 private void MoveCurrentCell (int x, int y, bool select, bool isControl, bool isShift, bool scroll)
6262                 {
6263                         if (x == -1 || y == -1)
6264                                 x = y = -1;
6265                         else {
6266                                 if (x < 0 || x > Columns.Count - 1)
6267                                         throw new ArgumentOutOfRangeException ("x");
6268                                 if (y < 0 || y > Rows.Count - 1)
6269                                         throw new ArgumentOutOfRangeException ("y");
6270
6271                                 if (!Rows[y].Visible) {
6272                                         for (int i = y; i < Rows.Count; i++) {
6273                                                 if (Rows[i].Visible) {
6274                                                         y = i;
6275                                                         break;
6276                                                 }
6277                                         }
6278                                 }
6279
6280                                 if (!Columns[x].Visible) {
6281                                         for (int i = x; i < Columns.Count; i++) {
6282                                                 if (Columns[i].Visible) {
6283                                                         x = i;
6284                                                         break;
6285                                                 }
6286                                         }
6287                                 }
6288
6289                                 // in case either no visible columns or rows
6290                                 if (!Rows[y].Visible || !Columns[x].Visible)
6291                                         x = y = -1;
6292                         }
6293
6294                         if (!SetCurrentCellAddressCore (x, y, true, false, false)) {
6295                                 ClearSelection ();
6296                                 return;
6297                         }
6298                         if (x == -1 && y == -1) {
6299                                 ClearSelection ();
6300                                 return;
6301                         }
6302
6303                         bool full_row_selected = Rows.SharedRow(CurrentCellAddress.Y).Selected;
6304                         bool full_col_selected = Columns[CurrentCellAddress.X].Selected;
6305
6306                         // Move Selection
6307                         DataGridViewSelectionMode mode = selectionMode;
6308
6309                         // If we are row header select and we clicked a row header, use full row
6310                         if (mode == DataGridViewSelectionMode.RowHeaderSelect && (x == -1 || (full_row_selected && CurrentCellAddress.X == x)))
6311                                 mode = DataGridViewSelectionMode.FullRowSelect;
6312                         else if (mode == DataGridViewSelectionMode.RowHeaderSelect)
6313                                 mode = DataGridViewSelectionMode.CellSelect;
6314
6315                         // If we are col header select and we clicked a col header, use full col
6316                         if (mode == DataGridViewSelectionMode.ColumnHeaderSelect && (y == -1 || (full_col_selected && CurrentCellAddress.Y == y)))
6317                                 mode = DataGridViewSelectionMode.FullColumnSelect;
6318                         else if (mode == DataGridViewSelectionMode.ColumnHeaderSelect)
6319                                 mode = DataGridViewSelectionMode.CellSelect;
6320
6321                         // If the current cell isn't visible, scroll to it
6322                         if (scroll) {
6323                                 int disp_x = ColumnIndexToDisplayIndex (x);
6324                                 bool scrollbarsRefreshed = false;
6325                                 int displayedColumnsCount = DisplayedColumnCount (false);
6326                                 int delta_x = 0;
6327
6328                                 // The trick here is that in order to avoid unnecessary calculations each time a row/column
6329                                 // is added/removed we recalculate the whole grid size just before the scroll to selection.
6330                                 if (disp_x < first_col_index) {
6331                                         RefreshScrollBars ();
6332                                         scrollbarsRefreshed = true;
6333
6334                                         if (disp_x == 0)
6335                                                 delta_x = horizontalScrollBar.Value;
6336                                         else {
6337                                                 // in case the column got removed
6338                                                 if (first_col_index >= ColumnCount)
6339                                                         first_col_index = ColumnCount - 1;
6340                                                 for (int i = disp_x; i < first_col_index; i++)
6341                                                         delta_x += Columns[ColumnDisplayIndexToIndex (i)].Width;
6342                                         }
6343
6344                                         horizontalScrollBar.SafeValueSet (horizontalScrollBar.Value - delta_x);
6345                                         OnHScrollBarScroll (this, new ScrollEventArgs (ScrollEventType.ThumbPosition, horizontalScrollBar.Value));
6346                                 } else if (disp_x > first_col_index + displayedColumnsCount - 1 && disp_x != 0) {
6347                                         RefreshScrollBars ();
6348                                         scrollbarsRefreshed = true;
6349
6350                                         if (disp_x == Columns.Count - 1)
6351                                                 delta_x = horizontalScrollBar.Maximum - horizontalScrollBar.Value;
6352                                         else
6353                                                 for (int i = first_col_index + displayedColumnsCount - 1; i < disp_x && i != -1; i++)
6354                                                         delta_x += Columns[ColumnDisplayIndexToIndex (i)].Width;
6355
6356                                         horizontalScrollBar.SafeValueSet (horizontalScrollBar.Value + delta_x);
6357                                         OnHScrollBarScroll (this, new ScrollEventArgs (ScrollEventType.ThumbPosition, horizontalScrollBar.Value));
6358                                 }
6359
6360                                 int disp_y = y;
6361                                 int displayedRowsCount = DisplayedRowCount (false);
6362                                 int delta_y = 0;
6363
6364                                 if (disp_y < first_row_index) {
6365                                         if (!scrollbarsRefreshed)
6366                                                 RefreshScrollBars ();
6367
6368                                         if (disp_y == 0)
6369                                                 delta_y = verticalScrollBar.Value;
6370                                         else {
6371                                                 // in case the row got removed
6372                                                 if (first_row_index >= RowCount)
6373                                                         first_row_index = RowCount - 1;
6374                                                 for (int i = disp_y; i < first_row_index; i++)
6375                                                         delta_y += GetRowInternal (i).Height;
6376                                         }
6377
6378                                         verticalScrollBar.SafeValueSet (verticalScrollBar.Value - delta_y);
6379                                         OnVScrollBarScroll (this, new ScrollEventArgs (ScrollEventType.ThumbPosition, verticalScrollBar.Value));
6380                                 } else if (disp_y > first_row_index + displayedRowsCount - 1 && disp_y != 0) {
6381                                         if (!scrollbarsRefreshed)
6382                                                 RefreshScrollBars ();
6383
6384                                         if (disp_y == Rows.Count - 1)
6385                                                 delta_y = verticalScrollBar.Maximum - verticalScrollBar.Value;
6386                                         else
6387                                                 for (int i = first_row_index + displayedRowsCount - 1; i < disp_y; i++)
6388                                                         delta_y += GetRowInternal (i).Height;
6389
6390                                         verticalScrollBar.SafeValueSet (verticalScrollBar.Value + delta_y);
6391                                         OnVScrollBarScroll (this, new ScrollEventArgs (ScrollEventType.ThumbPosition, verticalScrollBar.Value));
6392                                 }
6393                         }
6394
6395                         if (!select)
6396                                 return;
6397
6398                         // Clear old selection unless multi-selecting
6399                         if (!isShift)
6400                                 ClearSelection ();
6401
6402                         switch (mode) {
6403                                 case DataGridViewSelectionMode.CellSelect:
6404                                         SetSelectedCellCore (x, y, true);
6405                                         break;
6406                                 case DataGridViewSelectionMode.FullRowSelect:
6407                                         SetSelectedRowCore (y, true);
6408                                         break;
6409                                 case DataGridViewSelectionMode.FullColumnSelect:
6410                                         SetSelectedColumnCore (x, true);
6411                                         break;
6412                         }
6413
6414                         Invalidate ();
6415                 }
6416
6417                 private int ColumnIndexToDisplayIndex (int index)
6418                 {
6419                         if (index == -1)
6420                                 return index;
6421                         return Columns[index].DisplayIndex;
6422                 }
6423
6424                 private int ColumnDisplayIndexToIndex (int index)
6425                 {
6426                         return Columns.ColumnDisplayIndexSortedArrayList[index].Index;
6427                 }
6428
6429                 private void OnListChanged (object sender, ListChangedEventArgs args)
6430                 {
6431                         switch (args.ListChangedType) {
6432                                 case ListChangedType.ItemAdded:
6433                                         AddBoundRow (DataManager[args.NewIndex]);
6434                                         break;
6435                                 case ListChangedType.ItemDeleted:
6436                                         Rows.RemoveAtInternal (args.NewIndex);
6437                                         break;
6438                                 case ListChangedType.ItemChanged:
6439                                         break;
6440                                 default:
6441                                         ResetRows ();
6442                                         break;
6443                         }
6444
6445                         Invalidate ();
6446                 }
6447
6448                 private void OnListPositionChanged (object sender, EventArgs args)
6449                 {
6450                         if (Rows.Count > 0 && Columns.Count > 0 && DataManager.Position != -1)
6451                                 MoveCurrentCell (currentCell != null ? currentCell.ColumnIndex : 0, DataManager.Position,
6452                                                  true, false, false, true);
6453                         else
6454                                 MoveCurrentCell (-1, -1, true, false, false, true);
6455                 }
6456
6457                 private void ReBind ()
6458                 {
6459                         if (!is_binding) {
6460                                 SuspendLayout ();
6461
6462                                 is_binding = true;
6463                                 ClearBinding ();
6464                                 DoBinding ();
6465                                 is_binding = false;
6466
6467                                 ResumeLayout (true);
6468                                 Invalidate ();
6469                         }
6470                 }
6471
6472                 private bool MouseOverColumnResize (int col, int mousex)
6473                 {
6474                         if (!allowUserToResizeColumns)
6475                                 return false;
6476
6477                         Rectangle col_bounds = GetCellDisplayRectangle (col, 0, false);
6478
6479                         if (mousex >= col_bounds.Right - 4 && mousex <= col_bounds.Right)
6480                                 return true;
6481
6482                         return false;
6483                 }
6484
6485                 private bool MouseOverRowResize (int row, int mousey)
6486                 {
6487                         if (!allowUserToResizeRows)
6488                                 return false;
6489
6490                         Rectangle row_bounds = GetCellDisplayRectangle (0, row, false);
6491
6492                         if (mousey >= row_bounds.Bottom - 4 && mousey <= row_bounds.Bottom)
6493                                 return true;
6494
6495                         return false;
6496                 }
6497
6498                 private void DrawVerticalResizeLine (int x)
6499                 {
6500                         Rectangle splitter = new Rectangle (x, Bounds.Y + 3 + (ColumnHeadersVisible ? ColumnHeadersHeight : 0), 1, Bounds.Height - 3 - (ColumnHeadersVisible ? ColumnHeadersHeight : 0));
6501                         XplatUI.DrawReversibleRectangle (Handle, splitter, 2);
6502                 }
6503
6504                 private void DrawHorizontalResizeLine (int y)
6505                 {
6506                         Rectangle splitter = new Rectangle (Bounds.X + 3 + (RowHeadersVisible ? RowHeadersWidth : 0), y, Bounds.Width - 3 + (RowHeadersVisible ? RowHeadersWidth : 0), 1);
6507                         XplatUI.DrawReversibleRectangle (Handle, splitter, 2);
6508                 }
6509
6510                 #region Stuff for ToolTips
6511                 private void MouseEnteredErrorIcon (DataGridViewCell item)
6512                 {
6513                         tooltip_currently_showing = item;
6514                         ToolTipTimer.Start ();
6515                 }
6516
6517                 private void MouseLeftErrorIcon (DataGridViewCell item)
6518                 {
6519                         ToolTipTimer.Stop ();
6520                         ToolTipWindow.Hide (this);
6521                         tooltip_currently_showing = null;
6522                 }
6523
6524                 private Timer ToolTipTimer {
6525                         get {
6526                                 if (tooltip_timer == null) {
6527                                         tooltip_timer = new Timer ();
6528                                         tooltip_timer.Enabled = false;
6529                                         tooltip_timer.Interval = 500;
6530                                         tooltip_timer.Tick += new EventHandler (ToolTipTimer_Tick);
6531                                 }
6532
6533                                 return tooltip_timer;
6534                         }
6535                 }
6536
6537                 private ToolTip ToolTipWindow {
6538                         get {
6539                                 if (tooltip_window == null)
6540                                         tooltip_window = new ToolTip ();
6541
6542                                 return tooltip_window;
6543                         }
6544                 }
6545
6546                 private void ToolTipTimer_Tick (object o, EventArgs args)
6547                 {
6548                         string tooltip = tooltip_currently_showing.ErrorText;
6549
6550                         if (!string.IsNullOrEmpty (tooltip))
6551                                 ToolTipWindow.Present (this, tooltip);
6552
6553                         ToolTipTimer.Stop ();
6554                 }
6555                 #endregion
6556
6557                 private class ColumnSorter : IComparer
6558                 {
6559                         int column;
6560                         int direction = 1;
6561                         bool numeric_sort;
6562
6563                         public ColumnSorter (DataGridViewColumn column, ListSortDirection direction, bool numeric)
6564                         {
6565                                 this.column = column.Index;
6566                                 this.numeric_sort = numeric;
6567
6568                                 if (direction == ListSortDirection.Descending)
6569                                         this.direction = -1;
6570                         }
6571
6572                         #region IComparer Members
6573                         public int Compare (object x, object y)
6574                         {
6575                                 DataGridViewRow row1 = (DataGridViewRow)x;
6576                                 DataGridViewRow row2 = (DataGridViewRow)y;
6577
6578                                 if (row1.Cells[column].ValueType == typeof (DateTime) && row2.Cells[column].ValueType == typeof (DateTime))
6579                                         return DateTime.Compare ((DateTime)row1.Cells[column].Value, (DateTime)row2.Cells[column].Value) * direction;
6580
6581                                 object val1 = row1.Cells[column].FormattedValue;
6582                                 object val2 = row2.Cells[column].FormattedValue;
6583                                 object val1NullValue = row1.Cells[column].InheritedStyle.NullValue;
6584                                 object val2NullValue = row2.Cells[column].InheritedStyle.NullValue;
6585
6586                                 if (val1 == val1NullValue && val2 == val2NullValue)
6587                                         return 0;
6588                                 if (val1 == val1NullValue)
6589                                         return direction;
6590                                 if (val2 == val2NullValue)
6591                                         return -1 * direction;
6592
6593                                 if (numeric_sort)
6594                                         return (int)(double.Parse (val1.ToString ()) - double.Parse (val2.ToString ())) * direction;
6595                                 else
6596                                         return string.Compare (val1.ToString (), val2.ToString ()) * direction;
6597                         }
6598                         #endregion
6599                 }
6600
6601                 public sealed class HitTestInfo {
6602
6603                         public static readonly HitTestInfo Nowhere = new HitTestInfo(-1, -1, -1, -1, DataGridViewHitTestType.None);
6604
6605                         private int columnIndex;
6606                         private int columnX;
6607                         private int rowIndex;
6608                         private int rowY;
6609                         private DataGridViewHitTestType type;
6610
6611                         internal HitTestInfo (int columnIndex, int columnX, int rowIndex, int rowY, DataGridViewHitTestType type) {
6612                                 this.columnIndex = columnIndex;
6613                                 this.columnX = columnX;
6614                                 this.rowIndex = rowIndex;
6615                                 this.rowY = rowY;
6616                                 this.type = type;
6617                         }
6618
6619                         public int ColumnIndex {
6620                                 get { return columnIndex; }
6621                         }
6622
6623                         public int ColumnX {
6624                                 get { return columnX; }
6625                         }
6626
6627                         public int RowIndex {
6628                                 get { return rowIndex; }
6629                         }
6630
6631                         public int RowY {
6632                                 get { return rowY; }
6633                         }
6634
6635                         public DataGridViewHitTestType Type {
6636                                 get { return type; }
6637                         }
6638
6639                         public override bool Equals (object value) {
6640                                 if (value is HitTestInfo) {
6641                                         HitTestInfo aux = (HitTestInfo) value;
6642                                         if (aux.columnIndex == columnIndex && aux.columnX == columnX && aux.rowIndex == rowIndex && aux.rowY == rowY && aux.type == type) {
6643                                                 return true;
6644                                         }
6645                                 }
6646                                 return false;
6647                         }
6648
6649                         public override int GetHashCode () {
6650                                 return base.GetHashCode();
6651                         }
6652
6653                         public override string ToString () {
6654                                 return string.Format ("Type:{0}, Column:{1}, Row:{2}", type, columnIndex, rowIndex);
6655                         }
6656
6657                 }
6658
6659                 [ComVisible (false)]
6660                 public class DataGridViewControlCollection : Control.ControlCollection
6661                 {
6662                         private DataGridView owner;
6663
6664                         public DataGridViewControlCollection (DataGridView owner) : base (owner)
6665                         {
6666                                 this.owner = owner;
6667                         }
6668
6669                         public override void Clear ()
6670                         {
6671                                 //
6672                                 // This is severely buggy, just as MS' implementation is.
6673                                 //
6674                                 for (int i = 0; i < Count; i++) {
6675                                         Remove (this [i]);
6676                                 }
6677                         }
6678
6679                         public void CopyTo (Control [] array, int index)
6680                         {
6681                                 base.CopyTo (array, index);
6682                         }
6683
6684                         public void Insert (int index, Control value)
6685                         {
6686                                 throw new NotSupportedException ();
6687                         }
6688
6689                         public override void Remove (Control value)
6690                         {
6691                                 if (value == owner.horizontalScrollBar)
6692                                         return;
6693
6694                                 if (value == owner.verticalScrollBar)
6695                                         return;
6696
6697                                 if (value == owner.editingControl)
6698                                         return;
6699
6700                                 base.Remove (value);
6701                         }
6702
6703                         internal void RemoveInternal (Control value)
6704                         {
6705                                 base.Remove (value);
6706                         }
6707
6708
6709                 }
6710
6711                 [ComVisibleAttribute(true)]
6712                 protected class DataGridViewAccessibleObject : ControlAccessibleObject {
6713
6714                         public DataGridViewAccessibleObject (DataGridView owner) : base (owner){
6715                         }
6716
6717                         public override AccessibleRole Role {
6718                                 get { return base.Role; }
6719                         }
6720
6721                         public override string Name {
6722                                 get { return base.Name; }
6723                         }
6724
6725                         public override AccessibleObject GetChild (int index) {
6726                                 return base.GetChild(index);
6727                         }
6728
6729                         public override int GetChildCount () {
6730                                 return base.GetChildCount();
6731                         }
6732
6733                         public override AccessibleObject GetFocused () {
6734                                 return base.GetFocused();
6735                         }
6736
6737                         public override AccessibleObject GetSelected () {
6738                                 return base.GetSelected();
6739                         }
6740
6741                         public override AccessibleObject HitTest (int x, int y) {
6742                                 return base.HitTest(x, y);
6743                         }
6744
6745                         public override AccessibleObject Navigate( AccessibleNavigation navigationDirection) {
6746                                 return base.Navigate(navigationDirection);
6747                         }
6748
6749                 }
6750
6751                 [ComVisible (true)]
6752                 protected class DataGridViewTopRowAccessibleObject : AccessibleObject
6753                 {
6754                         #region Constructors
6755                         public DataGridViewTopRowAccessibleObject ()
6756                         {
6757                         }
6758
6759                         public DataGridViewTopRowAccessibleObject (DataGridView owner)
6760                         {
6761                                 this.owner = owner;
6762                         }
6763                         #endregion
6764
6765                         #region Public Methods
6766                         public override AccessibleObject GetChild (int index)
6767                         {
6768                                 return base.GetChild (index);
6769                         }
6770
6771                         public override int GetChildCount ()
6772                         {
6773                                 return base.GetChildCount ();
6774                         }
6775
6776                         public override AccessibleObject Navigate (AccessibleNavigation navigationDirection)
6777                         {
6778                                 return base.Navigate (navigationDirection);
6779                         }
6780                         #endregion
6781
6782                         #region Public Properties
6783                         public override Rectangle Bounds {
6784                                 get { return base.Bounds; }
6785                         }
6786
6787                         public override string Name {
6788                                 get { return base.Name; }
6789                         }
6790
6791                         public DataGridView Owner {
6792                                 get { return (DataGridView)owner; }
6793                                 set {
6794                                         if (owner != null)
6795                                                 throw new InvalidOperationException ("owner has already been set");
6796
6797                                         owner = value;
6798                                 }
6799                         }
6800
6801                         public override AccessibleObject Parent {
6802                                 get { return base.Parent; }
6803                         }
6804
6805                         public override AccessibleRole Role {
6806                                 get { return base.Role; }
6807                         }
6808
6809                         public override string Value {
6810                                 get { return base.Value; }
6811                         }
6812                         #endregion
6813                 }
6814         }
6815 }