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