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

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