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

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