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