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