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