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