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