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