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