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