mcs/class/Managed.Windows.Forms/System.Windows.Forms/DataGridView.cs

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