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

   1 // Permission is hereby granted, free of charge, to any person obtaining
   2 // a copy of this software and associated documentation files (the
   3 // "Software"), to deal in the Software without restriction, including
   4 // without limitation the rights to use, copy, modify, merge, publish,
   5 // distribute, sublicense, and/or sell copies of the Software, and to
   6 // permit persons to whom the Software is furnished to do so, subject to
   7 // the following conditions:
   8 //
   9 // The above copyright notice and this permission notice shall be
  10 // included in all copies or substantial portions of the Software.
  11 //
  12 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  13 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  14 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  15 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  16 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  17 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  18 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  19 //
  20 // Copyright (c) 2005 Novell, Inc. (http://www.novell.com)
  21 //
  22 // Author:
  23 //      Pedro Martínez Juliá <pedromj@gmail.com>
  24 //
  25
  26
  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
  37 namespace System.Windows.Forms {
  38
  39         [ComVisibleAttribute(true)]
  40         [ClassInterfaceAttribute(ClassInterfaceType.AutoDispatch)]
  41         [Designer("System.Windows.Forms.Design.DataGridViewDesigner, " + Consts.AssemblySystem_Design, "System.ComponentModel.Design.IDesigner")]
  42         [Editor("System.Windows.Forms.Design.DataGridViewComponentEditor, " + Consts.AssemblySystem_Design, typeof (System.ComponentModel.ComponentEditor))]
  43         [ComplexBindingProperties ("DataSource", "DataMember")]
  44         [DefaultEvent ("CellContentClick")]
  45         [Docking (DockingBehavior.Ask)]
  46         public class DataGridView : Control, ISupportInitialize, IBindableComponent, IDropTarget
  47         {
  48
  49                 private DataGridViewAdvancedBorderStyle adjustedTopLeftHeaderBorderStyle;
  50                 private DataGridViewAdvancedBorderStyle advancedCellBorderStyle;
  51                 private DataGridViewAdvancedBorderStyle advancedColumnHeadersBorderStyle;
  52                 private DataGridViewAdvancedBorderStyle advancedRowHeadersBorderStyle;
  53                 private bool allowUserToAddRows;
  54                 private bool allowUserToDeleteRows;
  55                 private bool allowUserToOrderColumns;
  56                 private bool allowUserToResizeColumns;
  57                 private bool allowUserToResizeRows;
  58                 private DataGridViewCellStyle alternatingRowsDefaultCellStyle;
  59                 private bool autoGenerateColumns;
  60                 private bool autoSize;
  61                 private DataGridViewAutoSizeColumnsMode autoSizeColumnsMode;
  62                 private DataGridViewAutoSizeRowsMode autoSizeRowsMode;
  63                 private Color backColor;
  64                 private Color backgroundColor;
  65                 private Image backgroundImage;
  66                 private BorderStyle borderStyle;
  67                 private DataGridViewCellBorderStyle cellBorderStyle;
  68                 private DataGridViewClipboardCopyMode clipboardCopyMode;
  69                 private DataGridViewHeaderBorderStyle columnHeadersBorderStyle;
  70                 private DataGridViewCellStyle columnHeadersDefaultCellStyle;
  71                 private int columnHeadersHeight;
  72                 private DataGridViewColumnHeadersHeightSizeMode columnHeadersHeightSizeMode;
  73                 private bool columnHeadersVisible;
  74                 private DataGridViewColumnCollection columns;
  75                 private DataGridViewCell currentCell;
  76                 private Point currentCellAddress;
  77                 private DataGridViewRow currentRow;
  78                 private string dataMember;
  79                 private object dataSource;
  80                 private DataGridViewCellStyle defaultCellStyle;
  81                 //private Control editingControl;
  82                 private DataGridViewEditMode editMode;
  83                 private bool enableHeadersVisualStyles;
  84                 private DataGridViewCell firstDisplayedCell;
  85                 private int firstDisplayedScrollingColumnHiddenWidth;
  86                 private int firstDisplayedScrollingColumnIndex;
  87                 private int firstDisplayedScrollingRowIndex;
  88                 private Color gridColor = Color.FromKnownColor(KnownColor.ControlDark);
  89                 private int horizontalScrollingOffset;
  90                 private bool isCurrentCellDirty;
  91                 //private bool isCurrentRowDirty;
  92                 private bool multiSelect;
  93                 private bool readOnly;
  94                 private DataGridViewHeaderBorderStyle rowHeadersBorderStyle;
  95                 private DataGridViewCellStyle rowHeadersDefaultCellStyle;
  96                 private bool rowHeadersVisible;
  97                 private int rowHeadersWidth;
  98                 private DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode;
  99                 private DataGridViewRowCollection rows;
 100                 private DataGridViewCellStyle rowsDefaultCellStyle;
 101                 private DataGridViewRow rowTemplate;
 102                 private ScrollBars scrollBars;
 103                 private DataGridViewSelectionMode selectionMode;
 104                 private bool showCellErrors;
 105                 private bool showCellToolTips;
 106                 private bool showEditingIcon;
 107                 private bool showRowErrors;
 108                 private DataGridViewColumn sortedColumn = null;
 109                 private SortOrder sortOrder;
 110                 private bool standardTab;
 111                 private DataGridViewHeaderCell topLeftHeaderCell;
 112                 private Cursor userSetCursor;
 113                 private int verticalScrollingOffset;
 114                 private bool virtualMode;
 115                 private HScrollBar horizontalScrollBar;
 116                 private VScrollBar verticalScrollBar;
 117
 118                 internal int gridWidth;
 119                 internal int gridHeight;
 120
 121                 public DataGridView () {
 122                         adjustedTopLeftHeaderBorderStyle = new DataGridViewAdvancedBorderStyle();
 123                         adjustedTopLeftHeaderBorderStyle.All = DataGridViewAdvancedCellBorderStyle.Single;
 124                         advancedCellBorderStyle = new DataGridViewAdvancedBorderStyle();
 125                         advancedCellBorderStyle.All = DataGridViewAdvancedCellBorderStyle.Single;
 126                         advancedColumnHeadersBorderStyle = new DataGridViewAdvancedBorderStyle();
 127                         advancedColumnHeadersBorderStyle.All = DataGridViewAdvancedCellBorderStyle.Single;
 128                         advancedRowHeadersBorderStyle = new DataGridViewAdvancedBorderStyle();
 129                         advancedRowHeadersBorderStyle.All = DataGridViewAdvancedCellBorderStyle.Single;
 130                         alternatingRowsDefaultCellStyle = new DataGridViewCellStyle();
 131                         allowUserToAddRows = true;
 132                         allowUserToDeleteRows = true;
 133                         allowUserToOrderColumns = false;
 134                         allowUserToResizeColumns = true;
 135                         allowUserToResizeRows = true;
 136                         autoGenerateColumns = true;
 137                         autoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.None;
 138                         autoSizeRowsMode = DataGridViewAutoSizeRowsMode.None;
 139                         backColor = Control.DefaultBackColor;
 140                         backgroundColor = SystemColors.AppWorkspace;
 141                         borderStyle = BorderStyle.FixedSingle;
 142                         cellBorderStyle = DataGridViewCellBorderStyle.None;
 143                         clipboardCopyMode = DataGridViewClipboardCopyMode.EnableWithAutoHeaderText;
 144                         columnHeadersBorderStyle = DataGridViewHeaderBorderStyle.Single;
 145                         columnHeadersDefaultCellStyle = new DataGridViewCellStyle();
 146                         columnHeadersDefaultCellStyle.BackColor = SystemColors.Control;
 147                         columnHeadersDefaultCellStyle.ForeColor = SystemColors.WindowText;
 148                         columnHeadersDefaultCellStyle.SelectionBackColor = SystemColors.Highlight;
 149                         columnHeadersDefaultCellStyle.SelectionForeColor = SystemColors.HighlightText;
 150                         columnHeadersDefaultCellStyle.Font = this.Font;
 151                         columnHeadersDefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleLeft;
 152                         columnHeadersDefaultCellStyle.WrapMode = DataGridViewTriState.True;
 153                         columnHeadersHeight = 23;
 154                         columnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.EnableResizing;
 155                         columnHeadersVisible = true;
 156                         columns = CreateColumnsInstance();
 157                         columns.CollectionChanged += OnColumnCollectionChanged;
 158                         dataMember = String.Empty;
 159                         defaultCellStyle = new DataGridViewCellStyle();
 160                         defaultCellStyle.BackColor = SystemColors.Window;
 161                         defaultCellStyle.ForeColor = SystemColors.ControlText;
 162                         defaultCellStyle.SelectionBackColor = SystemColors.Highlight;
 163                         defaultCellStyle.SelectionForeColor = SystemColors.HighlightText;
 164                         defaultCellStyle.Font = this.Font;
 165                         defaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleLeft;
 166                         defaultCellStyle.WrapMode = DataGridViewTriState.False;
 167                         editMode = DataGridViewEditMode.EditOnKeystrokeOrF2;
 168                         multiSelect = true;
 169                         readOnly = false;
 170                         rowHeadersBorderStyle = DataGridViewHeaderBorderStyle.Single;
 171                         rowHeadersDefaultCellStyle = (DataGridViewCellStyle) columnHeadersDefaultCellStyle.Clone ();
 172                         rowHeadersVisible = true;
 173                         rowHeadersWidth = 41;
 174                         rowHeadersWidthSizeMode = DataGridViewRowHeadersWidthSizeMode.EnableResizing;
 175                         rows = CreateRowsInstance();
 176                         rowsDefaultCellStyle = new DataGridViewCellStyle();
 177                         selectionMode = DataGridViewSelectionMode.RowHeaderSelect;
 178                         showCellErrors = true;
 179                         showEditingIcon = true;
 180                         userSetCursor = Cursor.Current;
 181                         virtualMode = false;
 182
 183                         horizontalScrollBar = new HScrollBar();
 184                         horizontalScrollBar.Dock = DockStyle.Bottom;
 185                         horizontalScrollBar.Scroll += OnHScrollBarScroll;
 186                         horizontalScrollBar.Visible = false;
 187                         verticalScrollBar = new VScrollBar();
 188                         verticalScrollBar.Dock = DockStyle.Right;
 189                         verticalScrollBar.Scroll += OnVScrollBarScroll;
 190                         verticalScrollBar.Visible = false;
 191                 }
 192
 193                 void ISupportInitialize.BeginInit ()
 194                 {
 195                 }
 196
 197                 void ISupportInitialize.EndInit ()
 198                 {
 199                 }
 200
 201                 // Propiedades
 202
 203                 [Browsable (false)]
 204                 [EditorBrowsable (EditorBrowsableState.Advanced)]
 205                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 206                 public virtual DataGridViewAdvancedBorderStyle AdjustedTopLeftHeaderBorderStyle {
 207                         get { return adjustedTopLeftHeaderBorderStyle; }
 208                 }
 209
 210                 [Browsable (false)]
 211                 [EditorBrowsable (EditorBrowsableState.Advanced)]
 212                 public DataGridViewAdvancedBorderStyle AdvancedCellBorderStyle {
 213                         get { return advancedCellBorderStyle; }
 214                 }
 215
 216                 [Browsable (false)]
 217                 [EditorBrowsable (EditorBrowsableState.Advanced)]
 218                 public DataGridViewAdvancedBorderStyle AdvancedColumnHeadersBorderStyle {
 219                         get { return advancedColumnHeadersBorderStyle; }
 220                 }
 221
 222                 [Browsable (false)]
 223                 [EditorBrowsable (EditorBrowsableState.Advanced)]
 224                 public DataGridViewAdvancedBorderStyle AdvancedRowHeadersBorderStyle {
 225                         get { return advancedRowHeadersBorderStyle; }
 226                 }
 227
 228                 [DefaultValue (true)]
 229                 public bool AllowUserToAddRows {
 230                         get { return allowUserToAddRows; }
 231                         set {
 232                                 if (allowUserToAddRows != value) {
 233                                         allowUserToAddRows = value;
 234                                         OnAllowUserToAddRowsChanged(EventArgs.Empty);
 235                                 }
 236                         }
 237                 }
 238
 239                 [DefaultValue (true)]
 240                 public bool AllowUserToDeleteRows {
 241                         get { return allowUserToDeleteRows; }
 242                         set {
 243                                 if (allowUserToDeleteRows != value) {
 244                                         allowUserToDeleteRows = value;
 245                                         OnAllowUserToDeleteRowsChanged(EventArgs.Empty);
 246                                 }
 247                         }
 248                 }
 249
 250                 [DefaultValue (false)]
 251                 public bool AllowUserToOrderColumns {
 252                         get { return allowUserToOrderColumns; }
 253                         set {
 254                                 if (allowUserToOrderColumns != value) {
 255                                         allowUserToOrderColumns = value;
 256                                         OnAllowUserToOrderColumnsChanged(EventArgs.Empty);
 257                                 }
 258                         }
 259                 }
 260
 261                 [DefaultValue (true)]
 262                 public bool AllowUserToResizeColumns {
 263                         get { return allowUserToResizeColumns; }
 264                         set {
 265                                 if (allowUserToResizeColumns != value) {
 266                                         allowUserToResizeColumns = value;
 267                                         OnAllowUserToResizeColumnsChanged(EventArgs.Empty);
 268                                 }
 269                         }
 270                 }
 271
 272                 [DefaultValue (true)]
 273                 public bool AllowUserToResizeRows {
 274                         get { return allowUserToResizeRows; }
 275                         set {
 276                                 if (allowUserToResizeRows != value) {
 277                                         allowUserToResizeRows = value;
 278                                         OnAllowUserToResizeRowsChanged(EventArgs.Empty);
 279                                 }
 280                         }
 281                 }
 282
 283                 public DataGridViewCellStyle AlternatingRowsDefaultCellStyle {
 284                         get { return alternatingRowsDefaultCellStyle; }
 285                         set {
 286                                 if (alternatingRowsDefaultCellStyle != value) {
 287                                         alternatingRowsDefaultCellStyle = value;
 288                                         OnAlternatingRowsDefaultCellStyleChanged(EventArgs.Empty);
 289                                         Invalidate();
 290                                 }
 291                         }
 292                 }
 293
 294                 [Browsable (false)]
 295                 [EditorBrowsable (EditorBrowsableState.Advanced)]
 296                 [DefaultValue (true)]
 297                 public bool AutoGenerateColumns {
 298                         get { return autoGenerateColumns; }
 299                         set {
 300                                 if (autoGenerateColumns != value) {
 301                                         autoGenerateColumns = value;
 302                                         OnAutoGenerateColumnsChanged(EventArgs.Empty);
 303                                 }
 304                         }
 305                 }
 306
 307                 public override bool AutoSize {
 308                         get { return autoSize; }
 309                         set {
 310                                 if (autoSize != value) {
 311                                         autoSize = value;
 312                                         //OnAutoSizeChanged(EventArgs.Empty);
 313                                 }
 314                         }
 315                 }
 316
 317                 [DefaultValue (DataGridViewAutoSizeColumnsMode.None)]
 318                 public DataGridViewAutoSizeColumnsMode AutoSizeColumnsMode {
 319                         get { return autoSizeColumnsMode; }
 320                         set {
 321                                 if (!Enum.IsDefined(typeof(DataGridViewAutoSizeColumnsMode), value)) {
 322                                         throw new InvalidEnumArgumentException("Value is not valid DataGridViewAutoSizeColumnsMode.");
 323                                 }
 324                                 if (value == DataGridViewAutoSizeColumnsMode.ColumnHeader && columnHeadersVisible == false) {
 325                                         foreach (DataGridViewColumn col in columns) {
 326                                                 if (col.AutoSizeMode == DataGridViewAutoSizeColumnMode.NotSet) {
 327                                                                 throw new InvalidOperationException("Cant set this property to ColumnHeader in this DataGridView.");
 328                                                 }
 329                                         }
 330                                 }
 331                                 if (value == DataGridViewAutoSizeColumnsMode.Fill) {
 332                                         foreach (DataGridViewColumn col in columns) {
 333                                                 if (col.AutoSizeMode == DataGridViewAutoSizeColumnMode.NotSet) {
 334                                                         if (col.Frozen) {
 335                                                                 throw new InvalidOperationException("Cant set this property to Fill in this DataGridView.");
 336                                                         }
 337                                                 }
 338                                         }
 339                                 }
 340                                 autoSizeColumnsMode = value;
 341                         }
 342                 }
 343
 344                 [DefaultValue (DataGridViewAutoSizeRowsMode.None)]
 345                 public DataGridViewAutoSizeRowsMode AutoSizeRowsMode {
 346                         get { return autoSizeRowsMode; }
 347                         set {
 348                                 if (autoSizeRowsMode != value) {
 349                                         if (!Enum.IsDefined(typeof(DataGridViewAutoSizeRowsMode), value)) {
 350                                                 throw new InvalidEnumArgumentException("Value is not valid DataGridViewRowsMode.");
 351                                         }
 352                                         if ((value == DataGridViewAutoSizeRowsMode.AllHeaders || value == DataGridViewAutoSizeRowsMode.DisplayedHeaders) && rowHeadersVisible == false) {
 353                                                 throw new InvalidOperationException("Cant set this property to AllHeaders or DisplayedHeaders in this DataGridView.");
 354                                         }
 355                                         autoSizeRowsMode = value;
 356                                         OnAutoSizeRowsModeChanged(new DataGridViewAutoSizeModeEventArgs(false));
 357                                         ////////////////////////////////////////////////////////////////
 358                                 }
 359                         }
 360                 }
 361
 362                 [Browsable (false)]
 363                 [EditorBrowsable (EditorBrowsableState.Never)]
 364                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 365                 public override Color BackColor {
 366                         get { return backColor; }
 367                         set {
 368                                 if (backColor != value) {
 369                                         backColor = value;
 370                                         OnBackColorChanged(EventArgs.Empty);
 371                                 }
 372                         }
 373                 }
 374
 375                 public Color BackgroundColor {
 376                         get { return backgroundColor; }
 377                         set {
 378                                 if (backgroundColor != value) {
 379                                         if (value == Color.Empty) {
 380                                                 throw new ArgumentException("Cant set an Empty color.");
 381                                         }
 382                                         backgroundColor = value;
 383                                         OnBackgroundColorChanged(EventArgs.Empty);
 384                                 }
 385                         }
 386                 }
 387
 388                 [Browsable (false)]
 389                 [EditorBrowsable (EditorBrowsableState.Never)]
 390                 public override Image BackgroundImage {
 391                         get { return backgroundImage; }
 392                         set {
 393                                 if (backgroundImage != value) {
 394                                         backgroundImage = value;
 395                                         OnBackgroundImageChanged(EventArgs.Empty);
 396                                 }
 397                         }
 398                 }
 399
 400                 [Browsable (false)]
 401                 [EditorBrowsable (EditorBrowsableState.Never)]
 402                 public override ImageLayout BackgroundImageLayout {
 403                         get { return base.BackgroundImageLayout; }
 404                         set { base.BackgroundImageLayout = value; }
 405                 }
 406
 407                 [DefaultValue (BorderStyle.FixedSingle)]
 408                 public BorderStyle BorderStyle {
 409                         get { return borderStyle; }
 410                         set {
 411                                 if (borderStyle != value) {
 412                                         if (!Enum.IsDefined(typeof(BorderStyle), value)) {
 413                                                 throw new InvalidEnumArgumentException("Invalid border style.");
 414                                         }
 415                                         borderStyle = value;
 416                                         OnBorderStyleChanged(EventArgs.Empty);
 417                                 }
 418                         }
 419                 }
 420
 421                 [Browsable (true)]
 422                 [DefaultValue (DataGridViewCellBorderStyle.Single)]
 423                 public DataGridViewCellBorderStyle CellBorderStyle {
 424                         get { return cellBorderStyle; }
 425                         set {
 426                                 if (cellBorderStyle != value) {
 427                                         cellBorderStyle = value;
 428                                         OnCellBorderStyleChanged(EventArgs.Empty);
 429                                 }
 430                         }
 431                 }
 432
 433                 [Browsable (true)]
 434                 [DefaultValue (DataGridViewClipboardCopyMode.EnableWithAutoHeaderText)]
 435                 public DataGridViewClipboardCopyMode ClipboardCopyMode {
 436                         get { return clipboardCopyMode; }
 437                         set { clipboardCopyMode = value; }
 438                 }
 439
 440                 [Browsable (false)]
 441                 [EditorBrowsable (EditorBrowsableState.Advanced)]
 442                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 443                 [DefaultValue (0)]
 444                 public int ColumnCount {
 445                         get { return columns.Count; }
 446                         set {
 447                                 if (value < 0) {
 448                                         throw new ArgumentOutOfRangeException("ColumnCount",
 449                                                 "ColumnCount must be >= 0.");
 450                                 }
 451                                 if (dataSource != null) {
 452                                         throw new InvalidOperationException("Cant change column count if DataSource is set.");
 453                                 }
 454                                 if (value < columns.Count) {
 455                                         for (int i = value; i < columns.Count; i++) {
 456                                                 columns.RemoveAt(i);
 457                                         }
 458                                 }
 459                                 else if (value > columns.Count) {
 460                                         for (int i = 0; i < value; i++) {
 461                                                 DataGridViewColumn col = new DataGridViewColumn();
 462                                                 columns.Add(col);
 463                                         }
 464                                 }
 465                         }
 466                 }
 467
 468                 [Browsable (true)]
 469                 [DefaultValue (DataGridViewHeaderBorderStyle.Raised)]
 470                 public DataGridViewHeaderBorderStyle ColumnHeadersBorderStyle {
 471                         get { return columnHeadersBorderStyle; }
 472                         set {
 473                                 if (columnHeadersBorderStyle != value) {
 474                                         columnHeadersBorderStyle = value;
 475                                         OnColumnHeadersBorderStyleChanged(EventArgs.Empty);
 476                                 }
 477                         }
 478                 }
 479
 480                 [AmbientValue (null)]
 481                 public DataGridViewCellStyle ColumnHeadersDefaultCellStyle {
 482                         get { return columnHeadersDefaultCellStyle; }
 483                         set {
 484                                 if (columnHeadersDefaultCellStyle != value) {
 485                                         columnHeadersDefaultCellStyle = value;
 486                                         OnColumnHeadersDefaultCellStyleChanged(EventArgs.Empty);
 487                                 }
 488                         }
 489                 }
 490
 491                 [Localizable (true)]
 492                 public int ColumnHeadersHeight {
 493                         get { return columnHeadersHeight; }
 494                         set {
 495                                 if (columnHeadersHeight != value) {
 496                                         if (value < 4) {
 497                                                 throw new ArgumentOutOfRangeException("ColumnHeadersHeight",
 498                                                         "Column headers height cant be less than 4.");
 499                                         }
 500                                         if (value > 32768 ) {
 501                                                 throw new ArgumentOutOfRangeException("ColumnHeadersHeight",
 502                                                         "Column headers height cannot be more than 32768.");
 503                                         }
 504                                         columnHeadersHeight = value;
 505                                         OnColumnHeadersHeightChanged(EventArgs.Empty);
 506                                 }
 507                         }
 508                 }
 509
 510                 [RefreshProperties (RefreshProperties.All)]
 511                 [DefaultValue (DataGridViewColumnHeadersHeightSizeMode.EnableResizing)]
 512                 public DataGridViewColumnHeadersHeightSizeMode ColumnHeadersHeightSizeMode {
 513                         get { return columnHeadersHeightSizeMode; }
 514                         set {
 515                                 if (columnHeadersHeightSizeMode != value) {
 516                                         if (!Enum.IsDefined(typeof(DataGridViewColumnHeadersHeightSizeMode), value)) {
 517                                                 throw new InvalidEnumArgumentException("Value is not a valid DataGridViewColumnHeadersHeightSizeMode.");
 518                                         }
 519                                         columnHeadersHeightSizeMode = value;
 520                                         OnColumnHeadersHeightSizeModeChanged(new DataGridViewAutoSizeModeEventArgs(false));
 521                                 }
 522                         }
 523                 }
 524
 525                 [DefaultValue (true)]
 526                 public bool ColumnHeadersVisible {
 527                         get { return columnHeadersVisible; }
 528                         set { columnHeadersVisible = value; }
 529                 }
 530
 531                 [MergableProperty (false)]
 532                 [Editor ("System.Windows.Forms.Design.DataGridViewColumnCollectionEditor, " + Consts.AssemblySystem_Design, typeof (System.Drawing.Design.UITypeEditor))]
 533                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]
 534                 public DataGridViewColumnCollection Columns {
 535                         get { return columns; }
 536                 }
 537
 538                 [Browsable (false)]
 539                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 540                 public DataGridViewCell CurrentCell {
 541                         get { return currentCell; }
 542                         set {
 543                                 /////////////////////////////////////////////////////
 544                                 /// *** InvalidOperationException ***
 545                                 /// Changes to the specified cell cannot be committed
 546                                 /// to the data cache, or the new cell is in a hidden
 547                                 /// row.
 548                                 /////////////////////////////////////////////////////
 549                                 if (value.DataGridView != this) {
 550                                         throw new ArgumentException("The cell is not in this DataGridView.");
 551                                 }
 552                                 currentCell = value;
 553                         }
 554                 }
 555
 556                 [Browsable (false)]
 557                 public Point CurrentCellAddress {
 558                         get { return currentCellAddress; }
 559                 }
 560
 561                 [Browsable (false)]
 562                 public DataGridViewRow CurrentRow {
 563                         get { return currentRow; }
 564                 }
 565
 566                 [DefaultValue ("")]
 567                 [Editor ("System.Windows.Forms.Design.DataMemberListEditor, " + Consts.AssemblySystem_Design, typeof (System.Drawing.Design.UITypeEditor))]
 568                 public string DataMember {
 569                         get { return dataMember; }
 570                         set {
 571                                 if (dataMember != value) {
 572                                         dataMember = value;
 573                                         OnDataMemberChanged(EventArgs.Empty);
 574                                 }
 575                         }
 576                 }
 577
 578                 [RefreshProperties (RefreshProperties.Repaint)]
 579                 [DefaultValue (null)]
 580                 [AttributeProvider (typeof (IListSource))]
 581                 // XXX AttributeProviderAtribute
 582                 public object DataSource {
 583                         get { return dataSource; }
 584                         set {
 585                                 if (dataSource != value) {
 586                                         /* 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:
 587                                          - the System.Collections.IList interface, including one-dimensional arrays.
 588                                          - the System.ComponentModel.IListSource interface, such as the System.Data.DataTable and System.Data.DataSet classes.
 589                                          - the System.ComponentModel.IBindingList interface, such as the System.ComponentModel.Collections.BindingList<> class.
 590                                          - the System.ComponentModel.IBindingListView interface, such as the System.Windows.Forms.BindingSource class.
 591                                         */
 592                                         if (!(value == null || value is IList || value is IListSource || value is IBindingList || value is IBindingListView)) {
 593                                                 throw new NotSupportedException("Type cant be binded.");
 594                                         }
 595                                         if (dataSource != null) {
 596                                                 columns.Clear();
 597                                                 rows.Clear();
 598                                                 if (dataSource is DataView) {
 599                                                         (dataSource as DataView).ListChanged -= OnListChanged;
 600                                                 }
 601                                                 if (dataSource is DataTable) {
 602                                                         ((dataSource as IListSource).GetList() as DataView).ListChanged -= OnListChanged;
 603                                                 }
 604                                         }
 605                                         dataSource = value;
 606                                         OnDataSourceChanged(EventArgs.Empty);
 607                                         if (dataSource != null) {
 608                                                 // DataBinding
 609                                                 if (value is IList) {
 610                                                         BindIList(value as IList);
 611                                                 }
 612                                                 else if (value is IListSource) {
 613                                                         BindIListSource(value as IListSource);
 614                                                 }
 615                                                 else if (value is IBindingList) {
 616                                                         BindIBindingList(value as IBindingList);
 617                                                 }
 618                                                 else if (value is IBindingListView) {
 619                                                         BindIBindingListView(value as IBindingListView);
 620                                                         //bool cosa = ((value as IBindingListView).SortDescriptions as IList).IsFixedSize;
 621                                                 }
 622                                                 OnDataBindingComplete(new DataGridViewBindingCompleteEventArgs(ListChangedType.Reset));
 623                                         }
 624                                         Invalidate();
 625                                 }
 626                         }
 627                 }
 628
 629                 [AmbientValue (null)]
 630                 public DataGridViewCellStyle DefaultCellStyle {
 631                         get { return defaultCellStyle; }
 632                         set {
 633                                 if (defaultCellStyle != value) {
 634                                         defaultCellStyle = value;
 635                                         OnDefaultCellStyleChanged(EventArgs.Empty);
 636                                 }
 637                         }
 638                 }
 639
 640                 public override Rectangle DisplayRectangle {
 641                         get { return base.DisplayRectangle; }
 642                 }
 643
 644                 [Browsable (false)]
 645                 [EditorBrowsable (EditorBrowsableState.Advanced)]
 646                 public Control EditingControl {
 647                         get {
 648                                 if (currentCell == null || !currentCell.IsInEditMode) {
 649                                         return null;
 650                                 }
 651                                 return (Control) Activator.CreateInstance(currentCell.EditType);
 652                         }
 653                 }
 654
 655                 [Browsable (false)]
 656                 [EditorBrowsable (EditorBrowsableState.Advanced)]
 657                 public Panel EditingPanel {
 658                         get { throw new NotImplementedException(); }
 659                 }
 660
 661                 [DefaultValue (DataGridViewEditMode.EditOnKeystrokeOrF2)]
 662                 public DataGridViewEditMode EditMode {
 663                         get { return editMode; }
 664                         set {
 665                                 if (editMode != value) {
 666                                         editMode = value;
 667                                         OnEditModeChanged(EventArgs.Empty);
 668                                 }
 669                         }
 670                 }
 671
 672                 [DefaultValue (true)]
 673                 public bool EnableHeadersVisualStyles {
 674                         get { return enableHeadersVisualStyles; }
 675                         set { enableHeadersVisualStyles = value; }
 676                 }
 677
 678                 [Browsable (false)]
 679                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 680                 public DataGridViewCell FirstDisplayedCell {
 681                         get { return firstDisplayedCell; }
 682                         set {
 683                                 if (value.DataGridView != this) {
 684                                         throw new ArgumentException("The cell is not in this DataGridView.");
 685                                 }
 686                                 firstDisplayedCell = value;
 687                         }
 688                 }
 689
 690                 [Browsable (false)]
 691                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 692                 [EditorBrowsable (EditorBrowsableState.Advanced)]
 693                 public int FirstDisplayedScrollingColumnHiddenWidth {
 694                         get { return firstDisplayedScrollingColumnHiddenWidth; }
 695                 }
 696
 697                 [Browsable (false)]
 698                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 699                 public int FirstDisplayedScrollingColumnIndex {
 700                         get { return firstDisplayedScrollingColumnIndex; }
 701                         set { firstDisplayedScrollingColumnIndex = value; }
 702                 }
 703
 704                 [Browsable (false)]
 705                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 706                 public int FirstDisplayedScrollingRowIndex {
 707                         get { return firstDisplayedScrollingRowIndex; }
 708                         set { firstDisplayedScrollingRowIndex = value; }
 709                 }
 710
 711                 [Browsable (false)]
 712                 [EditorBrowsable (EditorBrowsableState.Advanced)]
 713                 public override Font Font {
 714                         get { return base.Font; }
 715                         set { base.Font = value; }
 716                 }
 717
 718                 [Browsable (false)]
 719                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 720                 [EditorBrowsable (EditorBrowsableState.Advanced)]
 721                 public override Color ForeColor {
 722                         get { return base.ForeColor; }
 723                         set { base.ForeColor = value; }
 724                 }
 725
 726                 public Color GridColor {
 727                         get { return gridColor; }
 728                         set {
 729                                 if (gridColor != value) {
 730                                         if (value == Color.Empty) {
 731                                                 throw new ArgumentException("Cant set an Empty color.");
 732                                         }
 733                                         gridColor = value;
 734                                         OnGridColorChanged(EventArgs.Empty);
 735                                 }
 736                         }
 737                 }
 738
 739                 [Browsable (false)]
 740                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 741                 public int HorizontalScrollingOffset {
 742                         get { return horizontalScrollingOffset; }
 743                         set { horizontalScrollingOffset = value; }
 744                 }
 745
 746                 [Browsable (false)]
 747                 public bool IsCurrentCellDirty {
 748                         get { return isCurrentCellDirty; }
 749                 }
 750
 751                 [Browsable (false)]
 752                 public bool IsCurrentCellInEditMode {
 753                         get {
 754                                 if (currentCell == null) {
 755                                         return false;
 756                                 }
 757                                 return currentCell.IsInEditMode;
 758                         }
 759                 }
 760
 761                 [Browsable (false)]
 762                 public bool IsCurrentRowDirty {
 763                         get {
 764                                 if (!virtualMode) {
 765                                         return IsCurrentCellDirty;
 766                                 }
 767                                 // Calcular
 768                                 throw new NotImplementedException();
 769                         }
 770                 }
 771
 772                 [Browsable (false)]
 773                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 774                 public DataGridViewCell this [int columnIndex, int rowIndex] {
 775                         get { return rows[rowIndex].Cells[columnIndex]; }
 776                         set { rows[rowIndex].Cells[columnIndex] = value; }
 777                 }
 778
 779                 [Browsable (false)]
 780                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 781                 public DataGridViewCell this [string columnName, int rowIndex] {
 782                         get {
 783                                 int columnIndex = -1;
 784                                 foreach (DataGridViewColumn col in columns) {
 785                                         if (col.Name == columnName) {
 786                                                 columnIndex = col.Index;
 787                                                 break;
 788                                         }
 789                                 }
 790                                 return this[columnIndex, rowIndex];
 791                         }
 792                         set {
 793                                 int columnIndex = -1;
 794                                 foreach (DataGridViewColumn col in columns) {
 795                                         if (col.Name == columnName) {
 796                                                 columnIndex = col.Index;
 797                                                 break;
 798                                         }
 799                                 }
 800                                 this[columnIndex, rowIndex] = value;
 801                         }
 802                 }
 803
 804                 [DefaultValue (true)]
 805                 public bool MultiSelect {
 806                         get { return multiSelect; }
 807                         set {
 808                                 if (multiSelect != value) {
 809                                         multiSelect = value;
 810                                         OnMultiSelectChanged(EventArgs.Empty);
 811                                 }
 812                         }
 813                 }
 814
 815                 [Browsable (false)]
 816                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 817                 public int NewRowIndex {
 818                         get {
 819                                 if (!allowUserToAddRows) {
 820                                         return -1;
 821                                 }
 822                                 return rows.Count - 1;
 823                         }
 824                 }
 825
 826                 [Browsable (false)]
 827                 [EditorBrowsable (EditorBrowsableState.Never)]
 828                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 829                 public new Padding Padding {
 830                         get { return Padding.Empty; }
 831                         set { }
 832                 }
 833
 834                 [Browsable (true)]
 835                 [DefaultValue (false)]
 836                 public bool ReadOnly {
 837                         get { return readOnly; }
 838                         set {
 839                                 if (readOnly != value) {
 840                                         readOnly = value;
 841                                         OnReadOnlyChanged(EventArgs.Empty);
 842                                 }
 843                         }
 844                 }
 845
 846                 [Browsable (false)]
 847                 [EditorBrowsable (EditorBrowsableState.Advanced)]
 848                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 849                 [DefaultValue (0)]
 850                 public int RowCount {
 851                         get { return rows.Count; }
 852                         set {
 853                                 if (value < 0) {
 854                                         throw new ArgumentException("RowCount must be >= 0.");
 855                                 }
 856                                 if (value < 1 && allowUserToAddRows) {
 857                                         throw new ArgumentException("RowCount must be >= 1 if AllowUserToAddRows is true.");
 858                                 }
 859                                 if (dataSource != null) {
 860                                         throw new InvalidOperationException("Cant change row count if DataSource is set.");
 861                                 }
 862                                 if (value < rows.Count) {
 863                                         for (int i = value; i < rows.Count; i++) {
 864                                                 rows.RemoveAt(i);
 865                                         }
 866                                 }
 867                                 else if (value > rows.Count) {
 868                                         for (int i = 0; i < value; i++) {
 869                                                 // DataGridViewRow row = new DataGridViewRow(); //(DataGridViewRow) rowTemplate.Clone();
 870                                                 DataGridViewRow row = (DataGridViewRow) rowTemplate.Clone();
 871                                                 rows.Add(row);
 872                                                 foreach (DataGridViewColumn col in columns) {
 873                                                         row.Cells.Add(col.CellTemplate.Clone() as DataGridViewCell);
 874                                                 }
 875                                         }
 876                                 }
 877                                 if (ColumnCount == 0) {
 878                                         ///////////////////////////////////////////////////////////////
 879                                         //columns.Add(new DataGridViewTextBoxColumn());
 880                                         throw new NotImplementedException();
 881                                 }
 882                         }
 883                 }
 884
 885                 [Browsable (true)]
 886                 [DefaultValue (DataGridViewHeaderBorderStyle.Raised)]
 887                 public DataGridViewHeaderBorderStyle RowHeadersBorderStyle {
 888                         get { return rowHeadersBorderStyle; }
 889                         set {
 890                                 if (rowHeadersBorderStyle != value) {
 891                                         rowHeadersBorderStyle = value;
 892                                         OnRowHeadersBorderStyleChanged(EventArgs.Empty);
 893                                 }
 894                         }
 895                 }
 896
 897                 [AmbientValue (null)]
 898                 public DataGridViewCellStyle RowHeadersDefaultCellStyle {
 899                         get { return rowHeadersDefaultCellStyle; }
 900                         set {
 901                                 if (rowHeadersDefaultCellStyle != value) {
 902                                         rowHeadersDefaultCellStyle = value;
 903                                         OnRowHeadersDefaultCellStyleChanged(EventArgs.Empty);
 904                                 }
 905                         }
 906                 }
 907
 908                 [DefaultValue (true)]
 909                 public bool RowHeadersVisible {
 910                         get { return rowHeadersVisible; }
 911                         set { rowHeadersVisible = value; }
 912                 }
 913
 914                 [Localizable (true)]
 915                 public int RowHeadersWidth {
 916                         get { return rowHeadersWidth; }
 917                         set {
 918                                 if (rowHeadersWidth != value) {
 919                                         if (value < 4) {
 920                                                 throw new ArgumentOutOfRangeException("RowHeadersWidth",
 921                                                         "Row headers width cant be less than 4.");
 922                                         }
 923                                         if (value > 32768 ) {
 924                                                 throw new ArgumentOutOfRangeException("RowHeadersWidth",
 925                                                         "Row headers width cannot be more than 32768.");
 926                                         }
 927                                         rowHeadersWidth = value;
 928                                         OnRowHeadersWidthChanged(EventArgs.Empty);
 929                                 }
 930                         }
 931                 }
 932
 933                 [RefreshProperties (RefreshProperties.All)]
 934                 [DefaultValue (DataGridViewRowHeadersWidthSizeMode.EnableResizing)]
 935                 public DataGridViewRowHeadersWidthSizeMode RowHeadersWidthSizeMode {
 936                         get { return rowHeadersWidthSizeMode; }
 937                         set {
 938                                 if (rowHeadersWidthSizeMode != value) {
 939                                         if (!Enum.IsDefined(typeof(DataGridViewRowHeadersWidthSizeMode), value)) {
 940                                                 throw new InvalidEnumArgumentException("Value is not valid DataGridViewRowHeadersWidthSizeMode.");
 941                                         }
 942                                         rowHeadersWidthSizeMode = value;
 943                                         OnRowHeadersWidthSizeModeChanged(new DataGridViewAutoSizeModeEventArgs(false));
 944                                 }
 945                         }
 946                 }
 947
 948                 [Browsable (false)]
 949                 public DataGridViewRowCollection Rows {
 950                         get { return rows; }
 951                 }
 952
 953                 public DataGridViewCellStyle RowsDefaultCellStyle {
 954                         get { return rowsDefaultCellStyle; }
 955                         set {
 956                                 if (rowsDefaultCellStyle != value) {
 957                                         rowsDefaultCellStyle = value;
 958                                         OnRowsDefaultCellStyleChanged(EventArgs.Empty);
 959                                 }
 960                         }
 961                 }
 962
 963                 [Browsable (true)]
 964                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]
 965                 public DataGridViewRow RowTemplate {
 966                         get {
 967                                 if (rowTemplate == null) {
 968                                         return new DataGridViewRow();
 969                                 }
 970                                 return rowTemplate;
 971                         }
 972                         set {
 973                                 rowTemplate = value;
 974                                 rowTemplate.SetDataGridView(this);
 975                         }
 976                 }
 977
 978                 [DefaultValue (ScrollBars.Both)]
 979                 [Localizable (true)]
 980                 public ScrollBars ScrollBars {
 981                         get { return scrollBars; }
 982                         set {
 983                                 if (!Enum.IsDefined(typeof(ScrollBars), value)) {
 984                                         throw new InvalidEnumArgumentException("Invalid ScrollBars value.");
 985                                 }
 986                                 ////////////////////////////////////////////////////////////
 987                                 /// *** InvalidOperationException ***
 988                                 /// The System.Windows.Forms.DataGridView is unable to
 989                                 /// scroll due to a cell change that cannot be committed
 990                                 /// or canceled.
 991                                 ///////////////////////////////////////////////////////////
 992                                 scrollBars = value;
 993                         }
 994                 }
 995
 996                 [Browsable (false)]
 997                 public DataGridViewSelectedCellCollection SelectedCells {
 998                         get {
 999                                 DataGridViewSelectedCellCollection selectedCells = new DataGridViewSelectedCellCollection();
1000                                 foreach (DataGridViewRow row in rows) {
1001                                         foreach (DataGridViewCell cell in row.Cells) {
1002                                                 if (cell.Selected) {
1003                                                         selectedCells.InternalAdd(cell);
1004                                                 }
1005                                         }
1006                                 }
1007                                 return selectedCells;
1008                         }
1009                 }
1010
1011                 [Browsable (false)]
1012                 public DataGridViewSelectedColumnCollection SelectedColumns {
1013                         get {
1014                                 DataGridViewSelectedColumnCollection selectedColumns = new DataGridViewSelectedColumnCollection();
1015                                 if (selectionMode == DataGridViewSelectionMode.FullColumnSelect || selectionMode == DataGridViewSelectionMode.ColumnHeaderSelect) {
1016                                         foreach (DataGridViewColumn col in columns) {
1017                                                 if (col.Selected) {
1018                                                         selectedColumns.InternalAdd(col);
1019                                                 }
1020                                         }
1021                                 }
1022                                 return selectedColumns;
1023                         }
1024                 }
1025
1026                 [Browsable (false)]
1027                 public DataGridViewSelectedRowCollection SelectedRows {
1028                         get {
1029                                 DataGridViewSelectedRowCollection selectedRows = new DataGridViewSelectedRowCollection();
1030                                 if (selectionMode == DataGridViewSelectionMode.FullColumnSelect || selectionMode == DataGridViewSelectionMode.RowHeaderSelect) {
1031                                         foreach (DataGridViewRow row in rows) {
1032                                                 if (row.Selected) {
1033                                                         selectedRows.InternalAdd(row);
1034                                                 }
1035                                         }
1036                                 }
1037                                 return selectedRows;
1038                         }
1039                 }
1040
1041                 [Browsable (true)]
1042                 [DefaultValue (DataGridViewSelectionMode.RowHeaderSelect)]
1043                 public DataGridViewSelectionMode SelectionMode {
1044                         get { return selectionMode; }
1045                         set {
1046                                 if (!Enum.IsDefined(typeof(DataGridViewSelectionMode), value)) {
1047                                         throw new InvalidEnumArgumentException("Value is not valid DataGridViewSelectionMode.");
1048                                 }
1049                                 selectionMode = value;
1050                         }
1051                 }
1052
1053                 [DefaultValue (true)]
1054                 public bool ShowCellErrors {
1055                         get { return showCellErrors; }
1056                         set { showCellErrors = value; }
1057                 }
1058
1059                 [DefaultValue (true)]
1060                 public bool ShowCellToolTips {
1061                         get { return showCellToolTips; }
1062                         set { showCellToolTips = value; }
1063                 }
1064
1065                 [DefaultValue (true)]
1066                 public bool ShowEditingIcon {
1067                         get { return showEditingIcon; }
1068                         set { showEditingIcon = value; }
1069                 }
1070
1071                 [DefaultValue (true)]
1072                 public bool ShowRowErrors {
1073                         get { return showRowErrors; }
1074                         set { showRowErrors = value; }
1075                 }
1076
1077                 [Browsable (false)]
1078                 public DataGridViewColumn SortedColumn {
1079                         get { return sortedColumn; }
1080                 }
1081
1082                 [Browsable (false)]
1083                 public SortOrder SortOrder {
1084                         get { return sortOrder; }
1085                 }
1086
1087                 [DefaultValue (false)]
1088                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1089                 public bool StandardTab {
1090                         get { return standardTab; }
1091                         set { standardTab = value; }
1092                 }
1093
1094                 [Bindable (false)]
1095                 [Browsable (false)]
1096                 [EditorBrowsable (EditorBrowsableState.Never)]
1097                 public override string Text {
1098                         get { return base.Text; }
1099                         set { base.Text = value; }
1100                 }
1101
1102                 [Browsable (false)]
1103                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
1104                 public DataGridViewHeaderCell TopLeftHeaderCell {
1105                         get { return topLeftHeaderCell; }
1106                         set { topLeftHeaderCell = value; }
1107                 }
1108
1109                 [Browsable (false)]
1110                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1111                 public Cursor UserSetCursor {
1112                         get { return userSetCursor; }
1113                 }
1114
1115                 [Browsable (false)]
1116                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
1117                 public int VerticalScrollingOffset {
1118                         get { return verticalScrollingOffset; }
1119                 }
1120
1121                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1122                 [DefaultValue (false)]
1123                 public bool VirtualMode {
1124                         get { return virtualMode; }
1125                         set { virtualMode = value; }
1126                 }
1127
1128                 static object AllowUserToAddRowsChangedEvent = new object ();
1129                 static object AllowUserToDeleteRowsChangedEvent = new object ();
1130                 static object AllowUserToOrderColumnsChangedEvent = new object ();
1131                 static object AllowUserToResizeColumnsChangedEvent = new object ();
1132                 static object AllowUserToResizeRowsChangedEvent = new object ();
1133                 static object AlternatingRowsDefaultCellStyleChangedEvent = new object ();
1134                 static object AutoGenerateColumnsChangedEvent = new object ();
1135                 static object AutoSizeColumnModeChangedEvent = new object ();
1136                 static object AutoSizeColumnsModeChangedEvent = new object ();
1137                 static object AutoSizeRowsModeChangedEvent = new object ();
1138                 static object BackgroundColorChangedEvent = new object ();
1139                 static object BorderStyleChangedEvent = new object ();
1140                 static object CancelRowEditEvent = new object ();
1141                 static object CellBeginEditEvent = new object ();
1142                 static object CellBorderStyleChangedEvent = new object ();
1143                 static object CellClickEvent = new object ();
1144                 static object CellContentClickEvent = new object ();
1145                 static object CellContentDoubleClickEvent = new object ();
1146                 static object CellContextMenuStripChangedEvent = new object ();
1147                 static object CellContextMenuStripNeededEvent = new object ();
1148                 static object CellDoubleClickEvent = new object ();
1149                 static object CellEndEditEvent = new object ();
1150                 static object CellEnterEvent = new object ();
1151                 static object CellErrorTextChangedEvent = new object ();
1152                 static object CellErrorTextNeededEvent = new object ();
1153                 static object CellFormattingEvent = new object ();
1154                 static object CellLeaveEvent = new object ();
1155                 static object CellMouseClickEvent = new object ();
1156                 static object CellMouseDoubleClickEvent = new object ();
1157                 static object CellMouseDownEvent = new object ();
1158                 static object CellMouseEnterEvent = new object ();
1159                 static object CellMouseLeaveEvent = new object ();
1160                 static object CellMouseMoveEvent = new object ();
1161                 static object CellMouseUpEvent = new object ();
1162                 static object CellPaintingEvent = new object ();
1163                 static object CellParsingEvent = new object ();
1164                 static object CellStateChangedEvent = new object ();
1165                 static object CellStyleChangedEvent = new object ();
1166                 static object CellStyleContentChangedEvent = new object ();
1167                 static object CellToolTipTextChangedEvent = new object ();
1168                 static object CellToolTipTextNeededEvent = new object ();
1169                 static object CellValidatedEvent = new object ();
1170                 static object CellValidatingEvent = new object ();
1171                 static object CellValueChangedEvent = new object ();
1172                 static object CellValueNeededEvent = new object ();
1173                 static object CellValuePushedEvent = new object ();
1174                 static object ColumnAddedEvent = new object ();
1175                 static object ColumnContextMenuStripChangedEvent = new object ();
1176                 static object ColumnDataPropertyNameChangedEvent = new object ();
1177                 static object ColumnDefaultCellStyleChangedEvent = new object ();
1178                 static object ColumnDisplayIndexChangedEvent = new object ();
1179                 static object ColumnDividerDoubleClickEvent = new object ();
1180                 static object ColumnDividerWidthChangedEvent = new object ();
1181                 static object ColumnHeaderCellChangedEvent = new object ();
1182                 static object ColumnHeaderMouseClickEvent = new object ();
1183                 static object ColumnHeaderMouseDoubleClickEvent = new object ();
1184                 static object ColumnHeadersBorderStyleChangedEvent = new object ();
1185                 static object ColumnHeadersDefaultCellStyleChangedEvent = new object ();
1186                 static object ColumnHeadersHeightChangedEvent = new object ();
1187                 static object ColumnHeadersHeightSizeModeChangedEvent = new object ();
1188                 static object ColumnMinimumWidthChangedEvent = new object ();
1189                 static object ColumnNameChangedEvent = new object ();
1190                 static object ColumnRemovedEvent = new object ();
1191                 static object ColumnSortModeChangedEvent = new object ();
1192                 static object ColumnStateChangedEvent = new object ();
1193                 static object ColumnToolTipTextChangedEvent = new object ();
1194                 static object ColumnWidthChangedEvent = new object ();
1195                 static object CurrentCellChangedEvent = new object ();
1196                 static object CurrentCellDirtyStateChangedEvent = new object ();
1197                 static object DataBindingCompleteEvent = new object ();
1198                 static object DataErrorEvent = new object ();
1199                 static object DataMemberChangedEvent = new object ();
1200                 static object DataSourceChangedEvent = new object ();
1201                 static object DefaultCellStyleChangedEvent = new object ();
1202                 static object DefaultValuesNeededEvent = new object ();
1203                 static object EditingControlShowingEvent = new object ();
1204                 static object EditModeChangedEvent = new object ();
1205                 static object GridColorChangedEvent = new object ();
1206                 static object MultiSelectChangedEvent = new object ();
1207                 static object NewRowNeededEvent = new object ();
1208                 static object ReadOnlyChangedEvent = new object ();
1209                 static object RowContextMenuStripChangedEvent = new object ();
1210                 static object RowContextMenuStripNeededEvent = new object ();
1211                 static object RowDefaultCellStyleChangedEvent = new object ();
1212                 static object RowDirtyStateNeededEvent = new object ();
1213                 static object RowDividerDoubleClickEvent = new object ();
1214                 static object RowDividerHeightChangedEvent = new object ();
1215                 static object RowEnterEvent = new object ();
1216                 static object RowErrorTextChangedEvent = new object ();
1217                 static object RowErrorTextNeededEvent = new object ();
1218                 static object RowHeaderCellChangedEvent = new object ();
1219                 static object RowHeaderMouseClickEvent = new object ();
1220                 static object RowHeaderMouseDoubleClickEvent = new object ();
1221                 static object RowHeadersBorderStyleChangedEvent = new object ();
1222                 static object RowHeadersDefaultCellStyleChangedEvent = new object ();
1223                 static object RowHeadersWidthChangedEvent = new object ();
1224                 static object RowHeadersWidthSizeModeChangedEvent = new object ();
1225                 static object RowHeightChangedEvent = new object ();
1226                 static object RowHeightInfoNeededEvent = new object ();
1227                 static object RowHeightInfoPushedEvent = new object ();
1228                 static object RowLeaveEvent = new object ();
1229                 static object RowMinimumHeightChangedEvent = new object ();
1230                 static object RowPostPaintEvent = new object ();
1231                 static object RowPrePaintEvent = new object ();
1232                 static object RowsAddedEvent = new object ();
1233                 static object RowsDefaultCellStyleChangedEvent = new object ();
1234                 static object RowsRemovedEvent = new object ();
1235                 static object RowStateChangedEvent = new object ();
1236                 static object RowUnsharedEvent = new object ();
1237                 static object RowValidatedEvent = new object ();
1238                 static object RowValidatingEvent = new object ();
1239                 static object ScrollEvent = new object ();
1240                 static object SelectionChangedEvent = new object ();
1241                 static object SortCompareEvent = new object ();
1242                 static object SortedEvent = new object ();
1243                 static object UserAddedRowEvent = new object ();
1244                 static object UserDeletedRowEvent = new object ();
1245                 static object UserDeletingRowEvent = new object ();
1246
1247
1248                 //
1249
1250                 public event EventHandler AllowUserToAddRowsChanged {
1251                         add { Events.AddHandler (AllowUserToAddRowsChangedEvent, value); }
1252                         remove { Events.RemoveHandler (AllowUserToAddRowsChangedEvent, value); }
1253                 }
1254
1255                 public event EventHandler AllowUserToDeleteRowsChanged {
1256                         add { Events.AddHandler (AllowUserToDeleteRowsChangedEvent, value); }
1257                         remove { Events.RemoveHandler (AllowUserToDeleteRowsChangedEvent, value); }
1258                 }
1259
1260                 public event EventHandler AllowUserToOrderColumnsChanged {
1261                         add { Events.AddHandler (AllowUserToOrderColumnsChangedEvent, value); }
1262                         remove { Events.RemoveHandler (AllowUserToOrderColumnsChangedEvent, value); }
1263                 }
1264
1265                 public event EventHandler AllowUserToResizeColumnsChanged {
1266                         add { Events.AddHandler (AllowUserToResizeColumnsChangedEvent, value); }
1267                         remove { Events.RemoveHandler (AllowUserToResizeColumnsChangedEvent, value); }
1268                 }
1269
1270                 public event EventHandler AllowUserToResizeRowsChanged {
1271                         add { Events.AddHandler (AllowUserToResizeRowsChangedEvent, value); }
1272                         remove { Events.RemoveHandler (AllowUserToResizeRowsChangedEvent, value); }
1273                 }
1274
1275                 public event EventHandler AlternatingRowsDefaultCellStyleChanged {
1276                         add { Events.AddHandler (AlternatingRowsDefaultCellStyleChangedEvent, value); }
1277                         remove { Events.RemoveHandler (AlternatingRowsDefaultCellStyleChangedEvent, value); }
1278                 }
1279
1280                 [Browsable (false)]
1281                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1282                 public event EventHandler AutoGenerateColumnsChanged {
1283                         add { Events.AddHandler (AutoGenerateColumnsChangedEvent, value); }
1284                         remove { Events.RemoveHandler (AutoGenerateColumnsChangedEvent, value); }
1285                 }
1286
1287                 public event DataGridViewAutoSizeColumnModeEventHandler AutoSizeColumnModeChanged {
1288                         add { Events.AddHandler (AutoSizeColumnModeChangedEvent, value); }
1289                         remove { Events.RemoveHandler (AutoSizeColumnModeChangedEvent, value); }
1290                 }
1291
1292                 public event DataGridViewAutoSizeColumnsModeEventHandler AutoSizeColumnsModeChanged {
1293                         add { Events.AddHandler (AutoSizeColumnsModeChangedEvent, value); }
1294                         remove { Events.RemoveHandler (AutoSizeColumnsModeChangedEvent, value); }
1295                 }
1296
1297                 public event DataGridViewAutoSizeModeEventHandler AutoSizeRowsModeChanged {
1298                         add { Events.AddHandler (AutoSizeRowsModeChangedEvent, value); }
1299                         remove { Events.RemoveHandler (AutoSizeRowsModeChangedEvent, value); }
1300                 }
1301
1302                 [Browsable (false)]
1303                 [EditorBrowsable (EditorBrowsableState.Never)]
1304                 public new event EventHandler BackColorChanged {
1305                         add { base.BackColorChanged += value; }
1306                         remove { base.BackColorChanged -= value; }
1307                 }
1308
1309                 public event EventHandler BackgroundColorChanged {
1310                         add { Events.AddHandler (BackgroundColorChangedEvent, value); }
1311                         remove { Events.RemoveHandler (BackgroundColorChangedEvent, value); }
1312                 }
1313
1314                 [Browsable (false)]
1315                 [EditorBrowsable (EditorBrowsableState.Never)]
1316                 public new event EventHandler BackgroundImageChanged {
1317                         add { base.BackgroundImageChanged += value; }
1318                         remove { base.BackgroundImageChanged -= value; }
1319                 }
1320
1321                 [Browsable (false)]
1322                 [EditorBrowsable (EditorBrowsableState.Never)]
1323                 public new event EventHandler BackgroundImageLayoutChanged; /* XXX {
1324                         add { base.BackgroundImageLayoutChanged += value; }
1325                         remove { base.BackgroundImageLayoutChanged -= value; }
1326                 } */
1327
1328                 public event EventHandler BorderStyleChanged {
1329                         add { Events.AddHandler (BorderStyleChangedEvent, value); }
1330                         remove { Events.RemoveHandler (BorderStyleChangedEvent, value); }
1331                 }
1332
1333                 public event QuestionEventHandler CancelRowEdit {
1334                         add { Events.AddHandler (CancelRowEditEvent, value); }
1335                         remove { Events.RemoveHandler (CancelRowEditEvent, value); }
1336                 }
1337
1338                 public event DataGridViewCellCancelEventHandler CellBeginEdit {
1339                         add { Events.AddHandler (CellBeginEditEvent, value); }
1340                         remove { Events.RemoveHandler (CellBeginEditEvent, value); }
1341                 }
1342
1343                 public event EventHandler CellBorderStyleChanged {
1344                         add { Events.AddHandler (CellBorderStyleChangedEvent, value); }
1345                         remove { Events.RemoveHandler (CellBorderStyleChangedEvent, value); }
1346                 }
1347
1348                 public event DataGridViewCellEventHandler CellClick {
1349                         add { Events.AddHandler (CellClickEvent, value); }
1350                         remove { Events.RemoveHandler (CellClickEvent, value); }
1351                 }
1352
1353                 public event DataGridViewCellEventHandler CellContentClick {
1354                         add { Events.AddHandler (CellContentClickEvent, value); }
1355                         remove { Events.RemoveHandler (CellContentClickEvent, value); }
1356                 }
1357
1358                 public event DataGridViewCellEventHandler CellContentDoubleClick {
1359                         add { Events.AddHandler (CellContentDoubleClickEvent, value); }
1360                         remove { Events.RemoveHandler (CellContentDoubleClickEvent, value); }
1361                 }
1362
1363                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1364                 public event DataGridViewCellEventHandler CellContextMenuStripChanged {
1365                         add { Events.AddHandler (CellContextMenuStripChangedEvent, value); }
1366                         remove { Events.RemoveHandler (CellContextMenuStripChangedEvent, value); }
1367                 }
1368
1369                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1370                 public event DataGridViewCellContextMenuStripNeededEventHandler CellContextMenuStripNeeded {
1371                         add { Events.AddHandler (CellContextMenuStripNeededEvent, value); }
1372                         remove { Events.RemoveHandler (CellContextMenuStripNeededEvent, value); }
1373                 }
1374
1375                 public event DataGridViewCellEventHandler CellDoubleClick {
1376                         add { Events.AddHandler (CellDoubleClickEvent, value); }
1377                         remove { Events.RemoveHandler (CellDoubleClickEvent, value); }
1378                 }
1379
1380                 public event DataGridViewCellEventHandler CellEndEdit {
1381                         add { Events.AddHandler (CellEndEditEvent, value); }
1382                         remove { Events.RemoveHandler (CellEndEditEvent, value); }
1383                 }
1384
1385                 public event DataGridViewCellEventHandler CellEnter {
1386                         add { Events.AddHandler (CellEnterEvent, value); }
1387                         remove { Events.RemoveHandler (CellEnterEvent, value); }
1388                 }
1389
1390                 public event DataGridViewCellEventHandler CellErrorTextChanged {
1391                         add { Events.AddHandler (CellErrorTextChangedEvent, value); }
1392                         remove { Events.RemoveHandler (CellErrorTextChangedEvent, value); }
1393                 }
1394
1395                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1396                 public event DataGridViewCellErrorTextNeededEventHandler CellErrorTextNeeded {
1397                         add { Events.AddHandler (CellErrorTextNeededEvent, value); }
1398                         remove { Events.RemoveHandler (CellErrorTextNeededEvent, value); }
1399                 }
1400
1401                 public event DataGridViewCellFormattingEventHandler CellFormatting {
1402                         add { Events.AddHandler (CellFormattingEvent, value); }
1403                         remove { Events.RemoveHandler (CellFormattingEvent, value); }
1404                 }
1405
1406                 public event DataGridViewCellEventHandler CellLeave {
1407                         add { Events.AddHandler (CellLeaveEvent, value); }
1408                         remove { Events.RemoveHandler (CellLeaveEvent, value); }
1409                 }
1410
1411                 public event DataGridViewCellMouseEventHandler CellMouseClick {
1412                         add { Events.AddHandler (CellMouseClickEvent, value); }
1413                         remove { Events.RemoveHandler (CellMouseClickEvent, value); }
1414                 }
1415
1416                 public event DataGridViewCellMouseEventHandler CellMouseDoubleClick {
1417                         add { Events.AddHandler (CellMouseDoubleClickEvent, value); }
1418                         remove { Events.RemoveHandler (CellMouseDoubleClickEvent, value); }
1419                 }
1420
1421                 public event DataGridViewCellMouseEventHandler CellMouseDown {
1422                         add { Events.AddHandler (CellMouseDownEvent, value); }
1423                         remove { Events.RemoveHandler (CellMouseDownEvent, value); }
1424                 }
1425
1426                 public event DataGridViewCellEventHandler CellMouseEnter {
1427                         add { Events.AddHandler (CellMouseEnterEvent, value); }
1428                         remove { Events.RemoveHandler (CellMouseEnterEvent, value); }
1429                 }
1430
1431                 public event DataGridViewCellEventHandler CellMouseLeave {
1432                         add { Events.AddHandler (CellMouseLeaveEvent, value); }
1433                         remove { Events.RemoveHandler (CellMouseLeaveEvent, value); }
1434                 }
1435
1436                 public event DataGridViewCellMouseEventHandler CellMouseMove {
1437                         add { Events.AddHandler (CellMouseMoveEvent, value); }
1438                         remove { Events.RemoveHandler (CellMouseMoveEvent, value); }
1439                 }
1440
1441                 public event DataGridViewCellMouseEventHandler CellMouseUp {
1442                         add { Events.AddHandler (CellMouseUpEvent, value); }
1443                         remove { Events.RemoveHandler (CellMouseUpEvent, value); }
1444                 }
1445
1446                 public event DataGridViewCellPaintingEventHandler CellPainting {
1447                         add { Events.AddHandler (CellPaintingEvent, value); }
1448                         remove { Events.RemoveHandler (CellPaintingEvent, value); }
1449                 }
1450
1451                 public event DataGridViewCellParsingEventHandler CellParsing {
1452                         add { Events.AddHandler (CellParsingEvent, value); }
1453                         remove { Events.RemoveHandler (CellParsingEvent, value); }
1454                 }
1455
1456                 public event DataGridViewCellStateChangedEventHandler CellStateChanged {
1457                         add { Events.AddHandler (CellStateChangedEvent, value); }
1458                         remove { Events.RemoveHandler (CellStateChangedEvent, value); }
1459                 }
1460
1461                 public event DataGridViewCellEventHandler CellStyleChanged {
1462                         add { Events.AddHandler (CellStyleChangedEvent, value); }
1463                         remove { Events.RemoveHandler (CellStyleChangedEvent, value); }
1464                 }
1465
1466                 public event DataGridViewCellStyleContentChangedEventHandler CellStyleContentChanged {
1467                         add { Events.AddHandler (CellStyleContentChangedEvent, value); }
1468                         remove { Events.RemoveHandler (CellStyleContentChangedEvent, value); }
1469                 }
1470
1471                 public event DataGridViewCellEventHandler CellToolTipTextChanged {
1472                         add { Events.AddHandler (CellToolTipTextChangedEvent, value); }
1473                         remove { Events.RemoveHandler (CellToolTipTextChangedEvent, value); }
1474                 }
1475
1476                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1477                 public event DataGridViewCellToolTipTextNeededEventHandler CellToolTipTextNeeded {
1478                         add { Events.AddHandler (CellToolTipTextNeededEvent, value); }
1479                         remove { Events.RemoveHandler (CellToolTipTextNeededEvent, value); }
1480                 }
1481
1482                 public event DataGridViewCellEventHandler CellValidated {
1483                         add { Events.AddHandler (CellValidatedEvent, value); }
1484                         remove { Events.RemoveHandler (CellValidatedEvent, value); }
1485                 }
1486
1487                 public event DataGridViewCellValidatingEventHandler CellValidating {
1488                         add { Events.AddHandler (CellValidatingEvent, value); }
1489                         remove { Events.RemoveHandler (CellValidatingEvent, value); }
1490                 }
1491
1492                 public event DataGridViewCellEventHandler CellValueChanged {
1493                         add { Events.AddHandler (CellValueChangedEvent, value); }
1494                         remove { Events.RemoveHandler (CellValueChangedEvent, value); }
1495                 }
1496
1497                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1498                 public event DataGridViewCellValueEventHandler CellValueNeeded {
1499                         add { Events.AddHandler (CellValueNeededEvent, value); }
1500                         remove { Events.RemoveHandler (CellValueNeededEvent, value); }
1501                 }
1502
1503                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1504                 public event DataGridViewCellValueEventHandler CellValuePushed {
1505                         add { Events.AddHandler (CellValuePushedEvent, value); }
1506                         remove { Events.RemoveHandler (CellValuePushedEvent, value); }
1507                 }
1508
1509                 public event DataGridViewColumnEventHandler ColumnAdded {
1510                         add { Events.AddHandler (ColumnAddedEvent, value); }
1511                         remove { Events.RemoveHandler (ColumnAddedEvent, value); }
1512                 }
1513
1514                 public event DataGridViewColumnEventHandler ColumnContextMenuStripChanged {
1515                         add { Events.AddHandler (ColumnContextMenuStripChangedEvent, value); }
1516                         remove { Events.RemoveHandler (ColumnContextMenuStripChangedEvent, value); }
1517                 }
1518
1519                 public event DataGridViewColumnEventHandler ColumnDataPropertyNameChanged {
1520                         add { Events.AddHandler (ColumnDataPropertyNameChangedEvent, value); }
1521                         remove { Events.RemoveHandler (ColumnDataPropertyNameChangedEvent, value); }
1522                 }
1523
1524                 public event DataGridViewColumnEventHandler ColumnDefaultCellStyleChanged {
1525                         add { Events.AddHandler (ColumnDefaultCellStyleChangedEvent, value); }
1526                         remove { Events.RemoveHandler (ColumnDefaultCellStyleChangedEvent, value); }
1527                 }
1528
1529                 public event DataGridViewColumnEventHandler ColumnDisplayIndexChanged {
1530                         add { Events.AddHandler (ColumnDisplayIndexChangedEvent, value); }
1531                         remove { Events.RemoveHandler (ColumnDisplayIndexChangedEvent, value); }
1532                 }
1533
1534                 public event DataGridViewColumnDividerDoubleClickEventHandler ColumnDividerDoubleClick {
1535                         add { Events.AddHandler (ColumnDividerDoubleClickEvent, value); }
1536                         remove { Events.RemoveHandler (ColumnDividerDoubleClickEvent, value); }
1537                 }
1538
1539                 public event DataGridViewColumnEventHandler ColumnDividerWidthChanged {
1540                         add { Events.AddHandler (ColumnDividerWidthChangedEvent, value); }
1541                         remove { Events.RemoveHandler (ColumnDividerWidthChangedEvent, value); }
1542                 }
1543
1544                 public event DataGridViewColumnEventHandler ColumnHeaderCellChanged {
1545                         add { Events.AddHandler (ColumnHeaderCellChangedEvent, value); }
1546                         remove { Events.RemoveHandler (ColumnHeaderCellChangedEvent, value); }
1547                 }
1548
1549                 public event DataGridViewCellMouseEventHandler ColumnHeaderMouseClick {
1550                         add { Events.AddHandler (ColumnHeaderMouseClickEvent, value); }
1551                         remove { Events.RemoveHandler (ColumnHeaderMouseClickEvent, value); }
1552                 }
1553
1554                 public event DataGridViewCellMouseEventHandler ColumnHeaderMouseDoubleClick {
1555                         add { Events.AddHandler (ColumnHeaderMouseDoubleClickEvent, value); }
1556                         remove { Events.RemoveHandler (ColumnHeaderMouseDoubleClickEvent, value); }
1557                 }
1558
1559                 public event EventHandler ColumnHeadersBorderStyleChanged {
1560                         add { Events.AddHandler (ColumnHeadersBorderStyleChangedEvent, value); }
1561                         remove { Events.RemoveHandler (ColumnHeadersBorderStyleChangedEvent, value); }
1562                 }
1563
1564                 public event EventHandler ColumnHeadersDefaultCellStyleChanged {
1565                         add { Events.AddHandler (ColumnHeadersDefaultCellStyleChangedEvent, value); }
1566                         remove { Events.RemoveHandler (ColumnHeadersDefaultCellStyleChangedEvent, value); }
1567                 }
1568
1569                 public event EventHandler ColumnHeadersHeightChanged {
1570                         add { Events.AddHandler (ColumnHeadersHeightChangedEvent, value); }
1571                         remove { Events.RemoveHandler (ColumnHeadersHeightChangedEvent, value); }
1572                 }
1573
1574                 public event DataGridViewAutoSizeModeEventHandler ColumnHeadersHeightSizeModeChanged {
1575                         add { Events.AddHandler (ColumnHeadersHeightSizeModeChangedEvent, value); }
1576                         remove { Events.RemoveHandler (ColumnHeadersHeightSizeModeChangedEvent, value); }
1577                 }
1578
1579                 public event DataGridViewColumnEventHandler ColumnMinimumWidthChanged {
1580                         add { Events.AddHandler (ColumnMinimumWidthChangedEvent, value); }
1581                         remove { Events.RemoveHandler (ColumnMinimumWidthChangedEvent, value); }
1582                 }
1583
1584                 public event DataGridViewColumnEventHandler ColumnNameChanged {
1585                         add { Events.AddHandler (ColumnNameChangedEvent, value); }
1586                         remove { Events.RemoveHandler (ColumnNameChangedEvent, value); }
1587                 }
1588
1589                 public event DataGridViewColumnEventHandler ColumnRemoved {
1590                         add { Events.AddHandler (ColumnRemovedEvent, value); }
1591                         remove { Events.RemoveHandler (ColumnRemovedEvent, value); }
1592                 }
1593
1594                 public event DataGridViewColumnEventHandler ColumnSortModeChanged {
1595                         add { Events.AddHandler (ColumnSortModeChangedEvent, value); }
1596                         remove { Events.RemoveHandler (ColumnSortModeChangedEvent, value); }
1597                 }
1598
1599                 public event DataGridViewColumnStateChangedEventHandler ColumnStateChanged {
1600                         add { Events.AddHandler (ColumnStateChangedEvent, value); }
1601                         remove { Events.RemoveHandler (ColumnStateChangedEvent, value); }
1602                 }
1603
1604                 public event DataGridViewColumnEventHandler ColumnToolTipTextChanged {
1605                         add { Events.AddHandler (ColumnToolTipTextChangedEvent, value); }
1606                         remove { Events.RemoveHandler (ColumnToolTipTextChangedEvent, value); }
1607                 }
1608
1609                 public event DataGridViewColumnEventHandler ColumnWidthChanged {
1610                         add { Events.AddHandler (ColumnWidthChangedEvent, value); }
1611                         remove { Events.RemoveHandler (ColumnWidthChangedEvent, value); }
1612                 }
1613
1614                 public event EventHandler CurrentCellChanged {
1615                         add { Events.AddHandler (CurrentCellChangedEvent, value); }
1616                         remove { Events.RemoveHandler (CurrentCellChangedEvent, value); }
1617                 }
1618
1619                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1620                 public event EventHandler CurrentCellDirtyStateChanged {
1621                         add { Events.AddHandler (CurrentCellDirtyStateChangedEvent, value); }
1622                         remove { Events.RemoveHandler (CurrentCellDirtyStateChangedEvent, value); }
1623                 }
1624
1625                 public event DataGridViewBindingCompleteEventHandler DataBindingComplete {
1626                         add { Events.AddHandler (DataBindingCompleteEvent, value); }
1627                         remove { Events.RemoveHandler (DataBindingCompleteEvent, value); }
1628                 }
1629
1630                 public event DataGridViewDataErrorEventHandler DataError {
1631                         add { Events.AddHandler (DataErrorEvent, value); }
1632                         remove { Events.RemoveHandler (DataErrorEvent, value); }
1633                 }
1634
1635                 public event EventHandler DataMemberChanged {
1636                         add { Events.AddHandler (DataMemberChangedEvent, value); }
1637                         remove { Events.RemoveHandler (DataMemberChangedEvent, value); }
1638                 }
1639
1640                 public event EventHandler DataSourceChanged {
1641                         add { Events.AddHandler (DataSourceChangedEvent, value); }
1642                         remove { Events.RemoveHandler (DataSourceChangedEvent, value); }
1643                 }
1644
1645                 public event EventHandler DefaultCellStyleChanged {
1646                         add { Events.AddHandler (DefaultCellStyleChangedEvent, value); }
1647                         remove { Events.RemoveHandler (DefaultCellStyleChangedEvent, value); }
1648                 }
1649
1650                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1651                 public event DataGridViewRowEventHandler DefaultValuesNeeded {
1652                         add { Events.AddHandler (DefaultValuesNeededEvent, value); }
1653                         remove { Events.RemoveHandler (DefaultValuesNeededEvent, value); }
1654                 }
1655
1656                 public event DataGridViewEditingControlShowingEventHandler EditingControlShowing {
1657                         add { Events.AddHandler (EditingControlShowingEvent, value); }
1658                         remove { Events.RemoveHandler (EditingControlShowingEvent, value); }
1659                 }
1660
1661                 public event EventHandler EditModeChanged {
1662                         add { Events.AddHandler (EditModeChangedEvent, value); }
1663                         remove { Events.RemoveHandler (EditModeChangedEvent, value); }
1664                 }
1665
1666                 [Browsable (false)]
1667                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1668                 public new event EventHandler FontChanged {
1669                         add { base.FontChanged += value; }
1670                         remove { base.FontChanged -= value; }
1671                 }
1672
1673                 [Browsable (false)]
1674                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1675                 public new event EventHandler ForeColorChanged {
1676                         add { base.ForeColorChanged += value; }
1677                         remove { base.ForeColorChanged -= value; }
1678                 }
1679
1680                 [Browsable (false)]
1681                 [EditorBrowsable (EditorBrowsableState.Never)]
1682                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
1683                 public new event EventHandler PaddingChanged {
1684                         add { base.PaddingChanged += value; }
1685                         remove { base.PaddingChanged -= value; }
1686                 }
1687
1688                 public event EventHandler GridColorChanged {
1689                         add { Events.AddHandler (GridColorChangedEvent, value); }
1690                         remove { Events.RemoveHandler (GridColorChangedEvent, value); }
1691                 }
1692
1693                 public event EventHandler MultiSelectChanged {
1694                         add { Events.AddHandler (MultiSelectChangedEvent, value); }
1695                         remove { Events.RemoveHandler (MultiSelectChangedEvent, value); }
1696                 }
1697
1698                 public event DataGridViewRowEventHandler NewRowNeeded {
1699                         add { Events.AddHandler (NewRowNeededEvent, value); }
1700                         remove { Events.RemoveHandler (NewRowNeededEvent, value); }
1701                 }
1702
1703                 public event EventHandler ReadOnlyChanged {
1704                         add { Events.AddHandler (ReadOnlyChangedEvent, value); }
1705                         remove { Events.RemoveHandler (ReadOnlyChangedEvent, value); }
1706                 }
1707
1708                 public event DataGridViewRowEventHandler RowContextMenuStripChanged {
1709                         add { Events.AddHandler (RowContextMenuStripChangedEvent, value); }
1710                         remove { Events.RemoveHandler (RowContextMenuStripChangedEvent, value); }
1711                 }
1712
1713                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1714                 public event DataGridViewRowContextMenuStripNeededEventHandler RowContextMenuStripNeeded {
1715                         add { Events.AddHandler (RowContextMenuStripNeededEvent, value); }
1716                         remove { Events.RemoveHandler (RowContextMenuStripNeededEvent, value); }
1717                 }
1718
1719                 public event DataGridViewRowEventHandler RowDefaultCellStyleChanged {
1720                         add { Events.AddHandler (RowDefaultCellStyleChangedEvent, value); }
1721                         remove { Events.RemoveHandler (RowDefaultCellStyleChangedEvent, value); }
1722                 }
1723
1724                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1725                 public event QuestionEventHandler RowDirtyStateNeeded {
1726                         add { Events.AddHandler (RowDirtyStateNeededEvent, value); }
1727                         remove { Events.RemoveHandler (RowDirtyStateNeededEvent, value); }
1728                 }
1729
1730                 public event DataGridViewRowDividerDoubleClickEventHandler RowDividerDoubleClick {
1731                         add { Events.AddHandler (RowDividerDoubleClickEvent, value); }
1732                         remove { Events.RemoveHandler (RowDividerDoubleClickEvent, value); }
1733                 }
1734
1735                 public event DataGridViewRowEventHandler RowDividerHeightChanged {
1736                         add { Events.AddHandler (RowDividerHeightChangedEvent, value); }
1737                         remove { Events.RemoveHandler (RowDividerHeightChangedEvent, value); }
1738                 }
1739
1740                 public event DataGridViewCellEventHandler RowEnter {
1741                         add { Events.AddHandler (RowEnterEvent, value); }
1742                         remove { Events.RemoveHandler (RowEnterEvent, value); }
1743                 }
1744
1745                 public event DataGridViewRowEventHandler RowErrorTextChanged {
1746                         add { Events.AddHandler (RowErrorTextChangedEvent, value); }
1747                         remove { Events.RemoveHandler (RowErrorTextChangedEvent, value); }
1748                 }
1749
1750                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1751                 public event DataGridViewRowErrorTextNeededEventHandler RowErrorTextNeeded {
1752                         add { Events.AddHandler (RowErrorTextNeededEvent, value); }
1753                         remove { Events.RemoveHandler (RowErrorTextNeededEvent, value); }
1754                 }
1755
1756                 public event DataGridViewRowEventHandler RowHeaderCellChanged {
1757                         add { Events.AddHandler (RowHeaderCellChangedEvent, value); }
1758                         remove { Events.RemoveHandler (RowHeaderCellChangedEvent, value); }
1759                 }
1760
1761                 public event DataGridViewCellMouseEventHandler RowHeaderMouseClick {
1762                         add { Events.AddHandler (RowHeaderMouseClickEvent, value); }
1763                         remove { Events.RemoveHandler (RowHeaderMouseClickEvent, value); }
1764                 }
1765
1766                 public event DataGridViewCellMouseEventHandler RowHeaderMouseDoubleClick {
1767                         add { Events.AddHandler (RowHeaderMouseDoubleClickEvent, value); }
1768                         remove { Events.RemoveHandler (RowHeaderMouseDoubleClickEvent, value); }
1769                 }
1770
1771                 public event EventHandler RowHeadersBorderStyleChanged {
1772                         add { Events.AddHandler (RowHeadersBorderStyleChangedEvent, value); }
1773                         remove { Events.RemoveHandler (RowHeadersBorderStyleChangedEvent, value); }
1774                 }
1775
1776                 public event EventHandler RowHeadersDefaultCellStyleChanged {
1777                         add { Events.AddHandler (RowHeadersDefaultCellStyleChangedEvent, value); }
1778                         remove { Events.RemoveHandler (RowHeadersDefaultCellStyleChangedEvent, value); }
1779                 }
1780
1781                 public event EventHandler RowHeadersWidthChanged {
1782                         add { Events.AddHandler (RowHeadersWidthChangedEvent, value); }
1783                         remove { Events.RemoveHandler (RowHeadersWidthChangedEvent, value); }
1784                 }
1785
1786                 public event DataGridViewAutoSizeModeEventHandler RowHeadersWidthSizeModeChanged {
1787                         add { Events.AddHandler (RowHeadersWidthSizeModeChangedEvent, value); }
1788                         remove { Events.RemoveHandler (RowHeadersWidthSizeModeChangedEvent, value); }
1789                 }
1790
1791                 public event DataGridViewRowEventHandler RowHeightChanged {
1792                         add { Events.AddHandler (RowHeightChangedEvent, value); }
1793                         remove { Events.RemoveHandler (RowHeightChangedEvent, value); }
1794                 }
1795
1796                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1797                 public event DataGridViewRowHeightInfoNeededEventHandler RowHeightInfoNeeded {
1798                         add { Events.AddHandler (RowHeightInfoNeededEvent, value); }
1799                         remove { Events.RemoveHandler (RowHeightInfoNeededEvent, value); }
1800                 }
1801
1802                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1803                 public event DataGridViewRowHeightInfoPushedEventHandler RowHeightInfoPushed {
1804                         add { Events.AddHandler (RowHeightInfoPushedEvent, value); }
1805                         remove { Events.RemoveHandler (RowHeightInfoPushedEvent, value); }
1806                 }
1807
1808                 public event DataGridViewCellEventHandler RowLeave {
1809                         add { Events.AddHandler (RowLeaveEvent, value); }
1810                         remove { Events.RemoveHandler (RowLeaveEvent, value); }
1811                 }
1812
1813                 public event DataGridViewRowEventHandler RowMinimumHeightChanged {
1814                         add { Events.AddHandler (RowMinimumHeightChangedEvent, value); }
1815                         remove { Events.RemoveHandler (RowMinimumHeightChangedEvent, value); }
1816                 }
1817
1818                 public event DataGridViewRowPostPaintEventHandler RowPostPaint {
1819                         add { Events.AddHandler (RowPostPaintEvent, value); }
1820                         remove { Events.RemoveHandler (RowPostPaintEvent, value); }
1821                 }
1822
1823                 public event DataGridViewRowPrePaintEventHandler RowPrePaint {
1824                         add { Events.AddHandler (RowPrePaintEvent, value); }
1825                         remove { Events.RemoveHandler (RowPrePaintEvent, value); }
1826                 }
1827
1828                 public event DataGridViewRowsAddedEventHandler RowsAdded {
1829                         add { Events.AddHandler (RowsAddedEvent, value); }
1830                         remove { Events.RemoveHandler (RowsAddedEvent, value); }
1831                 }
1832
1833                 public event EventHandler RowsDefaultCellStyleChanged {
1834                         add { Events.AddHandler (RowsDefaultCellStyleChangedEvent, value); }
1835                         remove { Events.RemoveHandler (RowsDefaultCellStyleChangedEvent, value); }
1836                 }
1837
1838                 public event DataGridViewRowsRemovedEventHandler RowsRemoved {
1839                         add { Events.AddHandler (RowsRemovedEvent, value); }
1840                         remove { Events.RemoveHandler (RowsRemovedEvent, value); }
1841                 }
1842
1843                 public event DataGridViewRowStateChangedEventHandler RowStateChanged {
1844                         add { Events.AddHandler (RowStateChangedEvent, value); }
1845                         remove { Events.RemoveHandler (RowStateChangedEvent, value); }
1846                 }
1847
1848                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1849                 public event DataGridViewRowEventHandler RowUnshared {
1850                         add { Events.AddHandler (RowUnsharedEvent, value); }
1851                         remove { Events.RemoveHandler (RowUnsharedEvent, value); }
1852                 }
1853
1854                 public event DataGridViewCellEventHandler RowValidated {
1855                         add { Events.AddHandler (RowValidatedEvent, value); }
1856                         remove { Events.RemoveHandler (RowValidatedEvent, value); }
1857                 }
1858
1859                 public event DataGridViewCellCancelEventHandler RowValidating {
1860                         add { Events.AddHandler (RowValidatingEvent, value); }
1861                         remove { Events.RemoveHandler (RowValidatingEvent, value); }
1862                 }
1863
1864                 public event ScrollEventHandler Scroll {
1865                         add { Events.AddHandler (ScrollEvent, value); }
1866                         remove { Events.RemoveHandler (ScrollEvent, value); }
1867                 }
1868
1869                 public event EventHandler SelectionChanged {
1870                         add { Events.AddHandler (SelectionChangedEvent, value); }
1871                         remove { Events.RemoveHandler (SelectionChangedEvent, value); }
1872                 }
1873
1874                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1875                 public event DataGridViewSortCompareEventHandler SortCompare {
1876                         add { Events.AddHandler (SortCompareEvent, value); }
1877                         remove { Events.RemoveHandler (SortCompareEvent, value); }
1878                 }
1879
1880                 public event EventHandler Sorted {
1881                         add { Events.AddHandler (SortedEvent, value); }
1882                         remove { Events.RemoveHandler (SortedEvent, value); }
1883                 }
1884
1885                 public event DataGridViewRowEventHandler UserAddedRow {
1886                         add { Events.AddHandler (UserAddedRowEvent, value); }
1887                         remove { Events.RemoveHandler (UserAddedRowEvent, value); }
1888                 }
1889
1890                 public event DataGridViewRowEventHandler UserDeletedRow {
1891                         add { Events.AddHandler (UserDeletedRowEvent, value); }
1892                         remove { Events.RemoveHandler (UserDeletedRowEvent, value); }
1893                 }
1894
1895                 public event DataGridViewRowCancelEventHandler UserDeletingRow {
1896                         add { Events.AddHandler (UserDeletingRowEvent, value); }
1897                         remove { Events.RemoveHandler (UserDeletingRowEvent, value); }
1898                 }
1899
1900                 [Browsable (false)]
1901                 [EditorBrowsable (EditorBrowsableState.Never)]
1902                 public new event EventHandler StyleChanged {
1903                         add { base.StyleChanged += value; }
1904                         remove { base.StyleChanged -= value; }
1905                 }
1906
1907                 [Browsable (false)]
1908                 [EditorBrowsable (EditorBrowsableState.Never)]
1909                 public new event EventHandler TextChanged {
1910                         add { base.TextChanged += value; }
1911                         remove { base.TextChanged -= value; }
1912                 }
1913
1914                 [EditorBrowsable (EditorBrowsableState.Advanced)]
1915                 public virtual DataGridViewAdvancedBorderStyle AdjustColumnHeaderBorderStyle (DataGridViewAdvancedBorderStyle dataGridViewAdvancedBorderStyleInput, DataGridViewAdvancedBorderStyle dataGridViewAdvancedBorderStylePlaceholder, bool isFirstDisplayedColumn, bool isLastVisibleColumn) {
1916                         return (DataGridViewAdvancedBorderStyle) ((ICloneable)dataGridViewAdvancedBorderStyleInput).Clone();
1917                 }
1918
1919                 public bool AreAllCellsSelected (bool includeInvisibleCells) {
1920                         foreach (DataGridViewRow row in rows) {
1921                                 foreach (DataGridViewCell cell in row.Cells) {
1922                                         if (includeInvisibleCells == false && cell.Visible == false) {
1923                                                 continue;
1924                                         }
1925                                         if (!cell.Selected) {
1926                                                 return false;
1927                                         }
1928                                 }
1929                         }
1930                         return true;
1931                 }
1932
1933                 public void AutoResizeColumn (int columnIndex) {
1934                         throw new NotImplementedException();
1935                 }
1936
1937                 public void AutoResizeColumn (int columnIndex, DataGridViewAutoSizeColumnMode autoSizeColumnMode) {
1938                         throw new NotImplementedException();
1939                 }
1940
1941                 public void AutoResizeColumnHeadersHeight () {
1942                         throw new NotImplementedException();
1943                 }
1944
1945                 public void AutoResizeColumnHeadersHeight (int columnIndex) {
1946                         throw new NotImplementedException();
1947                 }
1948
1949                 public void AutoResizeColumns () {
1950                         throw new NotImplementedException();
1951                 }
1952
1953                 public void AutoResizeColumns (DataGridViewAutoSizeColumnsMode autoSizeColumnsMode) {
1954                         throw new NotImplementedException();
1955                 }
1956
1957                 public void AutoResizeRow (int rowIndex) {
1958                         throw new NotImplementedException();
1959                 }
1960
1961                 public void AutoResizeRow (int rowIndex, DataGridViewAutoSizeRowMode autoSizeRowMode) {
1962                         throw new NotImplementedException();
1963                 }
1964
1965                 public void AutoResizeRowHeadersWidth (DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode) {
1966                         throw new NotImplementedException();
1967                 }
1968
1969                 public void AutoResizeRowHeadersWidth (int rowIndex, DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode) {
1970                         throw new NotImplementedException();
1971                 }
1972
1973                 public void AutoResizeRows () {
1974                         throw new NotImplementedException();
1975                 }
1976
1977                 public void AutoResizeRows (DataGridViewAutoSizeRowsMode autoSizeRowsMode) {
1978                         if (!Enum.IsDefined(typeof(DataGridViewAutoSizeRowsMode), autoSizeRowsMode)) {
1979                                 throw new InvalidEnumArgumentException("Parameter AutoSizeRowsMode is not valid DataGridViewRowsMode.");
1980                         }
1981                         if ((autoSizeRowsMode == DataGridViewAutoSizeRowsMode.AllHeaders || autoSizeRowsMode == DataGridViewAutoSizeRowsMode.DisplayedHeaders) && rowHeadersVisible == false) {
1982                                 throw new InvalidOperationException("Parameter AutoSizeRowsMode cant be AllHeaders or DisplayedHeaders in this DataGridView.");
1983                         }
1984                         if (autoSizeRowsMode == DataGridViewAutoSizeRowsMode.None) {
1985                                 throw new ArgumentException("Parameter AutoSieRowsMode cant be None.");
1986                         }
1987                 }
1988
1989                 public virtual bool BeginEdit (bool selectAll) {
1990                         throw new NotImplementedException();
1991                 }
1992
1993                 public bool CancelEdit () {
1994                         throw new NotImplementedException();
1995                 }
1996
1997                 public void ClearSelection () {
1998                         foreach (DataGridViewCell cell in SelectedCells) {
1999                                 cell.Selected = false;
2000                         }
2001                 }
2002
2003                 public bool CommitEdit (DataGridViewDataErrorContexts context) {
2004                         throw new NotImplementedException();
2005                 }
2006
2007                 public int DisplayedColumnCount (bool includePartialColumns) {
2008                         /////////////////////// PartialColumns?
2009                         int result = 0;
2010                         foreach (DataGridViewColumn col in columns) {
2011                                 if (col.Visible) {
2012                                         result++;
2013                                 }
2014                         }
2015                         return result;
2016                 }
2017
2018                 public int DisplayedRowCount (bool includePartialRow) {
2019                         /////////////////////// PartialRows?
2020                         int result = 0;
2021                         foreach (DataGridViewRow row in rows) {
2022                                 if (row.Visible) {
2023                                         result++;
2024                                 }
2025                         }
2026                         return result;
2027                 }
2028
2029                 public bool EndEdit () {
2030                         throw new NotImplementedException();
2031                 }
2032
2033                 public bool EndEdit (DataGridViewDataErrorContexts context) {
2034                         throw new NotImplementedException();
2035                 }
2036
2037                 public int GetCellCount (DataGridViewElementStates includeFilter) {
2038                         int result = 0;
2039                         foreach (DataGridViewRow row in rows) {
2040                                 foreach (DataGridViewCell cell in row.Cells) {
2041                                         if ((cell.State & includeFilter) != 0) {
2042                                                 result++;
2043                                         }
2044                                 }
2045                         }
2046                         return result;
2047                 }
2048
2049                 public Rectangle GetCellDisplayRectangle (int columnIndex, int rowIndex, bool cutOverflow) {
2050                         if (columnIndex < 0 || columnIndex >= columns.Count) {
2051                                 throw new ArgumentOutOfRangeException("Column index is out of range.");
2052                         }
2053                         throw new NotImplementedException();
2054                 }
2055
2056                 public virtual DataObject GetClipboardContent () {
2057                         throw new NotImplementedException();
2058                 }
2059
2060                 public Rectangle GetColumnDisplayRectangle (int columnIndex, bool cutOverflow) {
2061                         throw new NotImplementedException();
2062                 }
2063
2064                 public Rectangle GetRowDisplayRectangle (int rowIndex, bool cutOverflow) {
2065                         throw new NotImplementedException();
2066                 }
2067
2068                 public HitTestInfo HitTest (int x, int y) {
2069                         ///////////////////////////////////////////////////////
2070                         x += horizontalScrollingOffset;
2071                         y += verticalScrollingOffset;
2072                         int rowIndex = -1;
2073                         int totalHeight = (columnHeadersVisible)? 1 + columnHeadersHeight : 1;
2074                         if (columnHeadersVisible && y <= totalHeight) {
2075                                 rowIndex = -1;
2076                         }
2077                         else {
2078                                 foreach (DataGridViewRow row in rows.RowIndexSortedArrayList) {
2079                                         totalHeight += row.Height;
2080                                         if (y <= totalHeight) {
2081                                                 rowIndex = row.Index;
2082                                                 break;
2083                                         }
2084                                         totalHeight++; // sumar el ancho de las lineas...
2085                                 }
2086                         }
2087                         int colIndex = -1;
2088                         int totalWidth = (rowHeadersVisible)? 1 + rowHeadersWidth : 1;
2089                         if (rowHeadersVisible && x <= totalWidth) {
2090                                 colIndex = -1;
2091                         }
2092                         else {
2093                                 foreach (DataGridViewColumn col in columns.ColumnDisplayIndexSortedArrayList) {
2094                                         totalWidth += col.Width;
2095                                         if (x <= totalWidth) {
2096                                                 colIndex = col.Index;
2097                                                 break;
2098                                         }
2099                                         totalWidth++;
2100                                 }
2101                         }
2102                         HitTestInfo result = new HitTestInfo(colIndex, x, rowIndex, y, (colIndex >= 0 && rowIndex >= 0)? DataGridViewHitTestType.Cell : DataGridViewHitTestType.None);
2103                         return result;
2104                 }
2105
2106                 public void InvalidateCell (DataGridViewCell dataGridViewCell) {
2107                         if (dataGridViewCell == null) {
2108                                 throw new ArgumentNullException("Cell is null");
2109                         }
2110                         if (dataGridViewCell.DataGridView != this) {
2111                                 throw new ArgumentException("The specified cell does not belong to this DataGridView.");
2112                         }
2113                         throw new NotImplementedException();
2114                 }
2115
2116                 public void InvalidateCell (int columnIndex, int rowIndex) {
2117                         if (columnIndex < 0 || columnIndex >= columns.Count) {
2118                                 throw new ArgumentOutOfRangeException("Column index is out of range.");
2119                         }
2120                         if (rowIndex < 0 || rowIndex >= rows.Count) {
2121                                 throw new ArgumentOutOfRangeException("Row index is out of range.");
2122                         }
2123                         foreach (DataGridViewRow row in rows) {
2124                                 foreach (DataGridViewCell cell in row.Cells) {
2125                                         if (cell.RowIndex == rowIndex && cell.ColumnIndex == columnIndex) {
2126                                                 InvalidateCell(cell); //// O al revés, que el otro llame a este !!!
2127                                                 return;
2128                                         }
2129                                 }
2130                         }
2131                 }
2132
2133                 public void InvalidateColumn (int columnIndex) {
2134                         if (columnIndex < 0 || columnIndex >= columns.Count) {
2135                                 throw new ArgumentOutOfRangeException("Column index is out of range.");
2136                         }
2137                         throw new NotImplementedException();
2138                 }
2139
2140                 public void InvalidateRow (int rowIndex) {
2141                         if (rowIndex < 0 || rowIndex >= rows.Count) {
2142                                 throw new ArgumentOutOfRangeException("Row index is out of range.");
2143                         }
2144                         throw new NotImplementedException();
2145                 }
2146
2147                 public virtual void NotifyCurrentCellDirty (bool dirty) {
2148                         throw new NotImplementedException();
2149                 }
2150
2151                 public bool RefreshEdit () {
2152                         throw new NotImplementedException();
2153                 }
2154
2155                 [EditorBrowsable (EditorBrowsableState.Never)]
2156                 public override void ResetText () {
2157                         throw new NotImplementedException();
2158                 }
2159
2160                 public void SelectAll () {
2161                         switch (selectionMode) {
2162                                 case DataGridViewSelectionMode.FullRowSelect:
2163                                         foreach (DataGridViewRow row in rows) {
2164                                                 (row as DataGridViewBand).Selected = true;
2165                                         }
2166                                         break;
2167                                 case DataGridViewSelectionMode.FullColumnSelect:
2168                                         foreach (DataGridViewColumn col in columns) {
2169                                                 (col as DataGridViewBand).Selected = true;
2170                                         }
2171                                         break;
2172                                 default:
2173                                         foreach (DataGridViewRow row in rows) {
2174                                                 foreach (DataGridViewCell cell in row.Cells) {
2175                                                         cell.Selected = true;
2176                                                 }
2177                                         }
2178                                         break;
2179                         }
2180                 }
2181
2182                 public virtual void Sort (IComparer comparer) {
2183                         throw new NotImplementedException();
2184                 }
2185
2186                 public virtual void Sort (DataGridViewColumn dataGridViewColumn, ListSortDirection direction) {
2187                         throw new NotImplementedException();
2188                 }
2189
2190                 public void UpdateCellErrorText (int columnIndex, int rowIndex)
2191                 {
2192                         throw new NotImplementedException();
2193                 }
2194
2195                 public void UpdateCellValue (int columnIndex, int rowIndex)
2196                 {
2197                         throw new NotImplementedException();
2198                 }
2199
2200                 public void UpdateRowErrorText (int rowIndex)
2201                 {
2202                         throw new NotImplementedException();
2203                 }
2204
2205                 public void UpdateRowErrorText (int rowIndexStart, int rowIndexEnd) {
2206                         throw new NotImplementedException();
2207                 }
2208
2209                 public void UpdateRowHeightInfo (int rowIndex, bool updateToEnd) {
2210                         throw new NotImplementedException();
2211                 }
2212
2213                 protected override Size DefaultSize {
2214                         get { return new Size (240, 150); }
2215                 }
2216
2217                 protected ScrollBar HorizontalScrollBar {
2218                         get { return horizontalScrollBar; }
2219                 }
2220
2221                 protected ScrollBar VerticalScrollBar {
2222                         get { return verticalScrollBar; }
2223                 }
2224
2225                 protected virtual void AccessibilityNotifyCurrentCellChanged (Point cellAddress)
2226                 {
2227                         throw new NotImplementedException ();
2228                 }
2229
2230                 protected void AutoResizeColumn (int columnIndex, DataGridViewAutoSizeColumnMode autoSizeColumnMode, bool fixedHeight) {
2231                         throw new NotImplementedException();
2232                 }
2233
2234                 protected void AutoResizeColumnHeadersHeight (bool fixedRowHeadersWidth, bool fixedColumnsWidth) {
2235                         throw new NotImplementedException();
2236                 }
2237
2238                 protected void AutoResizeColumnHeadersHeight (int columnIndex, bool fixedRowHeadersWidth, bool fixedColumnWidth) {
2239                         throw new NotImplementedException();
2240                 }
2241
2242                 protected void AutoResizeColumns (DataGridViewAutoSizeColumnsMode autoSizeColumnsMode, bool fixedHeight) {
2243                         throw new NotImplementedException();
2244                 }
2245
2246                 protected void AutoResizeRow (int rowIndex, DataGridViewAutoSizeRowMode autoSizeRowMode, bool fixedWidth) {
2247                         throw new NotImplementedException();
2248                 }
2249
2250                 protected void AutoResizeRowHeadersWidth (DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode, bool fixedColumnHeadersHeight, bool fixedRowsHeight) {
2251                         throw new NotImplementedException();
2252                 }
2253
2254                 protected void AutoResizeRowHeadersWidth (int rowIndex, DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode, bool fixedColumnHeadersHeight, bool fixedRowHeight) {
2255                         throw new NotImplementedException();
2256                 }
2257
2258                 protected void AutoResizeRows (DataGridViewAutoSizeRowsMode autoSizeRowsMode, bool fixedWidth) {
2259                         throw new NotImplementedException();
2260                 }
2261
2262                 protected void AutoResizeRows (int rowIndexStart, int rowsCount, DataGridViewAutoSizeRowMode autoSizeRowMode, bool fixedWidth) {
2263                         throw new NotImplementedException();
2264                 }
2265
2266                 protected void ClearSelection (int columnIndexException, int rowIndexException, bool selectExceptionElement) {
2267                         if (columnIndexException >= columns.Count) {
2268                                 throw new ArgumentOutOfRangeException("ColumnIndexException is greater than the highest column index.");
2269                         }
2270                         if (selectionMode == DataGridViewSelectionMode.FullRowSelect) {
2271                                 if (columnIndexException < -1) {
2272                                         throw new ArgumentOutOfRangeException("ColumnIndexException is less than -1.");
2273                                 }
2274                         }
2275                         else {
2276                                 if (columnIndexException < 0) {
2277                                         throw new ArgumentOutOfRangeException("ColumnIndexException is less than 0.");
2278                                 }
2279                         }
2280                         if (rowIndexException >= rows.Count) {
2281                                 throw new ArgumentOutOfRangeException("RowIndexException is greater than the highest row index.");
2282                         }
2283                         if (selectionMode == DataGridViewSelectionMode.FullColumnSelect) {
2284                                 if (rowIndexException < -1) {
2285                                         throw new ArgumentOutOfRangeException("RowIndexException is less than -1.");
2286                                 }
2287                         }
2288                         else {
2289                                 if (rowIndexException < 0) {
2290                                         throw new ArgumentOutOfRangeException("RowIndexException is less than 0.");
2291                                 }
2292                         }
2293                         switch (selectionMode) {
2294                                 case DataGridViewSelectionMode.FullRowSelect:
2295                                         foreach (DataGridViewRow row in rows) {
2296                                                 if (selectExceptionElement && row.Index == rowIndexException) {
2297                                                         continue;
2298                                                 }
2299                                                 row.Selected = false;
2300                                         }
2301                                         break;
2302                                 case DataGridViewSelectionMode.FullColumnSelect:
2303                                         foreach (DataGridViewColumn col in columns) {
2304                                                 if (selectExceptionElement && col.Index == columnIndexException) {
2305                                                         continue;
2306                                                 }
2307                                                 col.Selected = false;
2308                                         }
2309                                         break;
2310                                 default:
2311                                         foreach (DataGridViewCell cell in SelectedCells) {
2312                                                 if (selectExceptionElement && cell.RowIndex == rowIndexException && cell.ColumnIndex == columnIndexException) {
2313                                                         continue;
2314                                                 }
2315                                                 cell.Selected = false;
2316                                         }
2317                                         break;
2318                         }
2319                 }
2320
2321                 protected override AccessibleObject CreateAccessibilityInstance ()
2322                 {
2323                         return new DataGridViewAccessibleObject(this);
2324                 }
2325
2326                 [EditorBrowsable (EditorBrowsableState.Advanced)]
2327                 protected virtual DataGridViewColumnCollection CreateColumnsInstance ()
2328                 {
2329                         return new DataGridViewColumnCollection(this);
2330                 }
2331
2332                 protected override Control.ControlCollection CreateControlsInstance ()
2333                 {
2334                         return base.CreateControlsInstance(); //new Control.ControlCollection(this);
2335                 }
2336
2337                 [EditorBrowsable (EditorBrowsableState.Advanced)]
2338                 protected virtual DataGridViewRowCollection CreateRowsInstance ()
2339                 {
2340                         return new DataGridViewRowCollection(this);
2341                 }
2342
2343                 protected override void Dispose (bool disposing) {
2344                 }
2345
2346                 protected override AccessibleObject GetAccessibilityObjectById (int objectId)
2347                 {
2348                         throw new NotImplementedException();
2349                 }
2350
2351                 protected override bool IsInputChar (char charCode)
2352                 {
2353                         return base.IsInputChar(charCode);
2354                 }
2355
2356                 protected override bool IsInputKey (Keys keyData)
2357                 {
2358                         return base.IsInputKey(keyData);
2359                 }
2360
2361                 protected virtual void OnAllowUserToAddRowsChanged (EventArgs e)
2362                 {
2363                         EventHandler eh = (EventHandler)(Events [AllowUserToAddRowsChangedEvent]);
2364                         if (eh != null)
2365                                 eh (this, e);
2366                 }
2367
2368                 protected virtual void OnAllowUserToDeleteRowsChanged (EventArgs e)
2369                 {
2370                         EventHandler eh = (EventHandler)(Events [AllowUserToDeleteRowsChangedEvent]);
2371                         if (eh != null)
2372                                 eh (this, e);
2373                 }
2374
2375                 protected virtual void OnAllowUserToOrderColumnsChanged (EventArgs e)
2376                 {
2377                         EventHandler eh = (EventHandler)(Events [AllowUserToOrderColumnsChangedEvent]);
2378                         if (eh != null)
2379                                 eh (this, e);
2380                 }
2381
2382                 protected virtual void OnAllowUserToResizeColumnsChanged (EventArgs e)
2383                 {
2384                         EventHandler eh = (EventHandler)(Events [AllowUserToResizeColumnsChangedEvent]);
2385                         if (eh != null)
2386                                 eh (this, e);
2387                 }
2388
2389                 protected virtual void OnAllowUserToResizeRowsChanged (EventArgs e)
2390                 {
2391                         EventHandler eh = (EventHandler)(Events [AllowUserToResizeRowsChangedEvent]);
2392                         if (eh != null)
2393                                 eh (this, e);
2394                 }
2395
2396                 protected virtual void OnAlternatingRowsDefaultCellStyleChanged (EventArgs e)
2397                 {
2398                         EventHandler eh = (EventHandler)(Events [AlternatingRowsDefaultCellStyleChangedEvent]);
2399                         if (eh != null)
2400                                 eh (this, e);
2401                 }
2402
2403                 protected virtual void OnAutoGenerateColumnsChanged (EventArgs e)
2404                 {
2405                         EventHandler eh = (EventHandler)(Events [AutoGenerateColumnsChangedEvent]);
2406                         if (eh != null)
2407                                 eh (this, e);
2408                 }
2409
2410                 protected virtual void OnAutoSizeColumnModeChanged (DataGridViewAutoSizeColumnModeEventArgs e)
2411                 {
2412                         DataGridViewAutoSizeColumnModeEventHandler eh = (DataGridViewAutoSizeColumnModeEventHandler)(Events [AutoSizeColumnModeChangedEvent]);
2413                         if (eh != null)
2414                                 eh (this, e);
2415                 }
2416
2417                 protected virtual void OnAutoSizeColumnsModeChanged (DataGridViewAutoSizeColumnsModeEventArgs e)
2418                 {
2419                         DataGridViewAutoSizeColumnsModeEventHandler eh = (DataGridViewAutoSizeColumnsModeEventHandler)(Events [AutoSizeColumnsModeChangedEvent]);
2420                         if (eh != null)
2421                                 eh (this, e);
2422                 }
2423
2424                 protected virtual void OnAutoSizeRowsModeChanged (DataGridViewAutoSizeModeEventArgs e)
2425                 {
2426                         DataGridViewAutoSizeModeEventHandler eh = (DataGridViewAutoSizeModeEventHandler)(Events [AutoSizeRowsModeChangedEvent]);
2427                         if (eh != null)
2428                                 eh (this, e);
2429                 }
2430
2431                 protected virtual void OnBackgroundColorChanged (EventArgs e)
2432                 {
2433                         EventHandler eh = (EventHandler)(Events [BackgroundColorChangedEvent]);
2434                         if (eh != null)
2435                                 eh (this, e);
2436                 }
2437
2438                 protected override void OnBindingContextChanged (EventArgs e)
2439                 {
2440                         base.OnBindingContextChanged(e);
2441                 }
2442
2443                 protected virtual void OnBorderStyleChanged (EventArgs e)
2444                 {
2445                         EventHandler eh = (EventHandler)(Events [BorderStyleChangedEvent]);
2446                         if (eh != null)
2447                                 eh (this, e);
2448                 }
2449
2450                 protected virtual void OnCancelRowEdit (QuestionEventArgs e) {
2451                         QuestionEventHandler eh = (QuestionEventHandler)(Events [CancelRowEditEvent]);
2452                         if (eh != null)
2453                                 eh (this, e);
2454                 }
2455
2456                 protected virtual void OnCellBeginEdit (DataGridViewCellCancelEventArgs e)
2457                 {
2458                         DataGridViewCellCancelEventHandler eh = (DataGridViewCellCancelEventHandler)(Events [CellBeginEditEvent]);
2459                         if (eh != null)
2460                                 eh (this, e);
2461                 }
2462
2463                 protected virtual void OnCellBorderStyleChanged (EventArgs e)
2464                 {
2465                         EventHandler eh = (EventHandler)(Events [CellBorderStyleChangedEvent]);
2466                         if (eh != null)
2467                                 eh (this, e);
2468                 }
2469
2470                 protected virtual void OnCellClick (DataGridViewCellEventArgs e)
2471                 {
2472                         DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellClickEvent]);
2473                         if (eh != null)
2474                                 eh (this, e);
2475                 }
2476
2477                 protected virtual void OnCellContentClick (DataGridViewCellEventArgs e)
2478                 {
2479                         DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellContentClickEvent]);
2480                         if (eh != null)
2481                                 eh (this, e);
2482                 }
2483
2484                 protected virtual void OnCellContentDoubleClick (DataGridViewCellEventArgs e)
2485                 {
2486                         DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellContentDoubleClickEvent]);
2487                         if (eh != null)
2488                                 eh (this, e);
2489                 }
2490
2491                 protected virtual void OnCellContextMenuStripChanged (DataGridViewCellEventArgs e)
2492                 {
2493                         DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellContextMenuStripChangedEvent]);
2494                         if (eh != null)
2495                                 eh (this, e);
2496                 }
2497
2498                 protected virtual void OnCellContextMenuStripNeeded (DataGridViewCellContextMenuStripNeededEventArgs e)
2499                 {
2500                         DataGridViewCellContextMenuStripNeededEventHandler eh = (DataGridViewCellContextMenuStripNeededEventHandler)(Events [CellContextMenuStripNeededEvent]);
2501                         if (eh != null)
2502                                 eh (this, e);
2503                 }
2504
2505                 protected virtual void OnCellDoubleClick (DataGridViewCellEventArgs e)
2506                 {
2507                         DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellDoubleClickEvent]);
2508                         if (eh != null)
2509                                 eh (this, e);
2510                 }
2511
2512                 protected virtual void OnCellEndEdit (DataGridViewCellEventArgs e)
2513                 {
2514                         DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellEndEditEvent]);
2515                         if (eh != null)
2516                                 eh (this, e);
2517                 }
2518
2519                 protected virtual void OnCellEnter (DataGridViewCellEventArgs e)
2520                 {
2521                         DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellEnterEvent]);
2522                         if (eh != null)
2523                                 eh (this, e);
2524                 }
2525
2526                 protected internal virtual void OnCellErrorTextChanged (DataGridViewCellEventArgs e)
2527                 {
2528                         DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellErrorTextChangedEvent]);
2529                         if (eh != null)
2530                                 eh (this, e);
2531                 }
2532
2533                 protected virtual void OnCellErrorTextNeeded (DataGridViewCellErrorTextNeededEventArgs e)
2534                 {
2535                         DataGridViewCellErrorTextNeededEventHandler eh = (DataGridViewCellErrorTextNeededEventHandler)(Events [CellErrorTextNeededEvent]);
2536                         if (eh != null)
2537                                 eh (this, e);
2538                 }
2539
2540                 protected virtual void OnCellFormatting (DataGridViewCellFormattingEventArgs e)
2541                 {
2542                         DataGridViewCellFormattingEventHandler eh = (DataGridViewCellFormattingEventHandler)(Events [CellFormattingEvent]);
2543                         if (eh != null)
2544                                 eh (this, e);
2545                 }
2546
2547                 protected virtual void OnCellLeave (DataGridViewCellEventArgs e)
2548                 {
2549                         DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellLeaveEvent]);
2550                         if (eh != null)
2551                                 eh (this, e);
2552                 }
2553
2554                 protected virtual void OnCellMouseClick (DataGridViewCellMouseEventArgs e)
2555                 {
2556                         DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [CellMouseClickEvent]);
2557                         if (eh != null)
2558                                 eh (this, e);
2559                 }
2560
2561                 protected virtual void OnCellMouseDoubleClick (DataGridViewCellMouseEventArgs e)
2562                 {
2563                         DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [CellMouseDoubleClickEvent]);
2564                         if (eh != null)
2565                                 eh (this, e);
2566                 }
2567
2568                 protected virtual void OnCellMouseDown (DataGridViewCellMouseEventArgs e)
2569                 {
2570                         DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [CellMouseDownEvent]);
2571                         if (eh != null)
2572                                 eh (this, e);
2573                 }
2574
2575                 protected virtual void OnCellMouseEnter (DataGridViewCellEventArgs e)
2576                 {
2577                         DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellMouseEnterEvent]);
2578                         if (eh != null)
2579                                 eh (this, e);
2580                 }
2581
2582                 protected virtual void OnCellMouseLeave (DataGridViewCellEventArgs e)
2583                 {
2584                         DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellMouseLeaveEvent]);
2585                         if (eh != null)
2586                                 eh (this, e);
2587                 }
2588
2589                 protected virtual void OnCellMouseMove (DataGridViewCellMouseEventArgs e)
2590                 {
2591                         DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [CellMouseMoveEvent]);
2592                         if (eh != null)
2593                                 eh (this, e);
2594                 }
2595
2596                 protected virtual void OnCellMouseUp (DataGridViewCellMouseEventArgs e)
2597                 {
2598                         DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [CellMouseUpEvent]);
2599                         if (eh != null)
2600                                 eh (this, e);
2601                 }
2602
2603                 protected virtual void OnCellPainting (DataGridViewCellPaintingEventArgs e)
2604                 {
2605                         DataGridViewCellPaintingEventHandler eh = (DataGridViewCellPaintingEventHandler)(Events [CellPaintingEvent]);
2606                         if (eh != null)
2607                                 eh (this, e);
2608                 }
2609
2610                 protected internal virtual void OnCellParsing (DataGridViewCellParsingEventArgs e)
2611                 {
2612                         DataGridViewCellParsingEventHandler eh = (DataGridViewCellParsingEventHandler)(Events [CellParsingEvent]);
2613                         if (eh != null)
2614                                 eh (this, e);
2615                 }
2616
2617                 protected virtual void OnCellStateChanged (DataGridViewCellStateChangedEventArgs e)
2618                 {
2619                         DataGridViewCellStateChangedEventHandler eh = (DataGridViewCellStateChangedEventHandler)(Events [CellStateChangedEvent]);
2620                         if (eh != null)
2621                                 eh (this, e);
2622                 }
2623
2624                 protected virtual void OnCellStyleChanged (DataGridViewCellEventArgs e)
2625                 {
2626                         DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellStyleChangedEvent]);
2627                         if (eh != null)
2628                                 eh (this, e);
2629                 }
2630
2631                 protected virtual void OnCellStyleContentChanged (DataGridViewCellStyleContentChangedEventArgs e) {
2632                         DataGridViewCellStyleContentChangedEventHandler eh = (DataGridViewCellStyleContentChangedEventHandler)(Events [CellStyleContentChangedEvent]);
2633                         if (eh != null)
2634                                 eh (this, e);
2635                 }
2636
2637                 protected virtual void OnCellToolTipTextChanged (DataGridViewCellEventArgs e) {
2638                         DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellToolTipTextChangedEvent]);
2639                         if (eh != null)
2640                                 eh (this, e);
2641                 }
2642
2643                 protected virtual void OnCellToolTipTextNeeded (DataGridViewCellToolTipTextNeededEventArgs e)
2644                 {
2645                         DataGridViewCellToolTipTextNeededEventHandler eh = (DataGridViewCellToolTipTextNeededEventHandler)(Events [CellToolTipTextNeededEvent]);
2646                         if (eh != null)
2647                                 eh (this, e);
2648                 }
2649
2650                 protected virtual void OnCellValidated (DataGridViewCellEventArgs e)
2651                 {
2652                         DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellValidatedEvent]);
2653                         if (eh != null)
2654                                 eh (this, e);
2655                 }
2656
2657                 protected virtual void OnCellValidating (DataGridViewCellValidatingEventArgs e)
2658                 {
2659                         DataGridViewCellValidatingEventHandler eh = (DataGridViewCellValidatingEventHandler)(Events [CellValidatingEvent]);
2660                         if (eh != null)
2661                                 eh (this, e);
2662                 }
2663
2664                 protected virtual void OnCellValueChanged (DataGridViewCellEventArgs e)
2665                 {
2666                         DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellValueChangedEvent]);
2667                         if (eh != null)
2668                                 eh (this, e);
2669                 }
2670
2671                 protected virtual void OnCellValueNeeded (DataGridViewCellValueEventArgs e)
2672                 {
2673                         DataGridViewCellValueEventHandler eh = (DataGridViewCellValueEventHandler)(Events [CellValueNeededEvent]);
2674                         if (eh != null)
2675                                 eh (this, e);
2676                 }
2677
2678                 protected virtual void OnCellValuePushed (DataGridViewCellValueEventArgs e)
2679                 {
2680                         DataGridViewCellValueEventHandler eh = (DataGridViewCellValueEventHandler)(Events [CellValuePushedEvent]);
2681                         if (eh != null)
2682                                 eh (this, e);
2683                 }
2684
2685                 protected virtual void OnColumnAdded (DataGridViewColumnEventArgs e)
2686                 {
2687                         DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnAddedEvent]);
2688                         if (eh != null)
2689                                 eh (this, e);
2690                 }
2691
2692                 protected internal virtual void OnColumnContextMenuStripChanged (DataGridViewColumnEventArgs e)
2693                 {
2694                         DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnContextMenuStripChangedEvent]);
2695                         if (eh != null)
2696                                 eh (this, e);
2697                 }
2698
2699                 protected internal virtual void OnColumnDataPropertyNameChanged (DataGridViewColumnEventArgs e)
2700                 {
2701                         DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnDataPropertyNameChangedEvent]);
2702                         if (eh != null)
2703                                 eh (this, e);
2704                 }
2705
2706                 protected internal virtual void OnColumnDefaultCellStyleChanged (DataGridViewColumnEventArgs e)
2707                 {
2708                         DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnDefaultCellStyleChangedEvent]);
2709                         if (eh != null)
2710                                 eh (this, e);
2711                 }
2712
2713                 protected internal virtual void OnColumnDisplayIndexChanged (DataGridViewColumnEventArgs e)
2714                 {
2715                         DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnDisplayIndexChangedEvent]);
2716                         if (eh != null)
2717                                 eh (this, e);
2718                 }
2719
2720                 protected virtual void OnColumnDividerDoubleClick (DataGridViewColumnDividerDoubleClickEventArgs e)
2721                 {
2722                         DataGridViewColumnDividerDoubleClickEventHandler eh = (DataGridViewColumnDividerDoubleClickEventHandler)(Events [ColumnDividerDoubleClickEvent]);
2723                         if (eh != null)
2724                                 eh (this, e);
2725                 }
2726
2727                 protected internal virtual void OnColumnDividerWidthChanged (DataGridViewColumnEventArgs e)
2728                 {
2729                         DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnDividerWidthChangedEvent]);
2730                         if (eh != null)
2731                                 eh (this, e);
2732                 }
2733
2734                 protected internal virtual void OnColumnHeaderCellChanged (DataGridViewColumnEventArgs e)
2735                 {
2736                         DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnHeaderCellChangedEvent]);
2737                         if (eh != null)
2738                                 eh (this, e);
2739                 }
2740
2741                 protected virtual void OnColumnHeaderMouseClick (DataGridViewCellMouseEventArgs e)
2742                 {
2743                         DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [ColumnHeaderMouseClickEvent]);
2744                         if (eh != null)
2745                                 eh (this, e);
2746                 }
2747
2748                 protected virtual void OnColumnHeaderMouseDoubleClick (DataGridViewCellMouseEventArgs e)
2749                 {
2750                         DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [ColumnHeaderMouseDoubleClickEvent]);
2751                         if (eh != null)
2752                                 eh (this, e);
2753                 }
2754
2755                 protected virtual void OnColumnHeadersBorderStyleChanged (EventArgs e)
2756                 {
2757                         EventHandler eh = (EventHandler)(Events [ColumnHeadersBorderStyleChangedEvent]);
2758                         if (eh != null)
2759                                 eh (this, e);
2760                 }
2761
2762                 protected virtual void OnColumnHeadersDefaultCellStyleChanged (EventArgs e)
2763                 {
2764                         EventHandler eh = (EventHandler)(Events [ColumnHeadersDefaultCellStyleChangedEvent]);
2765                         if (eh != null)
2766                                 eh (this, e);
2767                 }
2768
2769                 protected virtual void OnColumnHeadersHeightChanged (EventArgs e)
2770                 {
2771                         EventHandler eh = (EventHandler)(Events [ColumnHeadersHeightChangedEvent]);
2772                         if (eh != null)
2773                                 eh (this, e);
2774                 }
2775
2776                 protected virtual void OnColumnHeadersHeightSizeModeChanged (DataGridViewAutoSizeModeEventArgs e)
2777                 {
2778                         DataGridViewAutoSizeModeEventHandler eh = (DataGridViewAutoSizeModeEventHandler)(Events [ColumnHeadersHeightSizeModeChangedEvent]);
2779                         if (eh != null)
2780                                 eh (this, e);
2781                 }
2782
2783                 protected internal virtual void OnColumnMinimumWidthChanged (DataGridViewColumnEventArgs e)
2784                 {
2785                         DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnMinimumWidthChangedEvent]);
2786                         if (eh != null)
2787                                 eh (this, e);
2788                 }
2789
2790                 protected internal virtual void OnColumnNameChanged (DataGridViewColumnEventArgs e)
2791                 {
2792                         DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnNameChangedEvent]);
2793                         if (eh != null)
2794                                 eh (this, e);
2795                 }
2796
2797                 protected virtual void OnColumnRemoved (DataGridViewColumnEventArgs e)
2798                 {
2799                         DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnRemovedEvent]);
2800                         if (eh != null)
2801                                 eh (this, e);
2802                 }
2803
2804                 protected internal virtual void OnColumnSortModeChanged (DataGridViewColumnEventArgs e)
2805                 {
2806                         DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnSortModeChangedEvent]);
2807                         if (eh != null)
2808                                 eh (this, e);
2809                 }
2810
2811                 protected internal virtual void OnColumnStateChanged (DataGridViewColumnStateChangedEventArgs e)
2812                 {
2813                         DataGridViewColumnStateChangedEventHandler eh = (DataGridViewColumnStateChangedEventHandler)(Events [ColumnStateChangedEvent]);
2814                         if (eh != null)
2815                                 eh (this, e);
2816                 }
2817
2818                 protected internal virtual void OnColumnToolTipTextChanged (DataGridViewColumnEventArgs e)
2819                 {
2820                         DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnToolTipTextChangedEvent]);
2821                         if (eh != null)
2822                                 eh (this, e);
2823                 }
2824
2825                 protected internal virtual void OnColumnWidthChanged (DataGridViewColumnEventArgs e)
2826                 {
2827                         DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnWidthChangedEvent]);
2828                         if (eh != null)
2829                                 eh (this, e);
2830                 }
2831
2832                 protected virtual void OnCurrentCellChanged (EventArgs e)
2833                 {
2834                         EventHandler eh = (EventHandler)(Events [CurrentCellChangedEvent]);
2835                         if (eh != null)
2836                                 eh (this, e);
2837                 }
2838
2839                 protected virtual void OnCurrentCellDirtyStateChanged (EventArgs e)
2840                 {
2841                         EventHandler eh = (EventHandler)(Events [CurrentCellDirtyStateChangedEvent]);
2842                         if (eh != null)
2843                                 eh (this, e);
2844                 }
2845
2846                 protected override void OnCursorChanged (EventArgs e)
2847                 {
2848                         base.OnCursorChanged (e);
2849                 }
2850
2851                 protected virtual void OnDataBindingComplete (DataGridViewBindingCompleteEventArgs e)
2852                 {
2853                         DataGridViewBindingCompleteEventHandler eh = (DataGridViewBindingCompleteEventHandler)(Events [DataBindingCompleteEvent]);
2854                         if (eh != null)
2855                                 eh (this, e);
2856                 }
2857
2858                 protected virtual void OnDataError (bool displayErrorDialogIfNoHandler, DataGridViewDataErrorEventArgs e) {
2859                         DataGridViewDataErrorEventHandler eh = (DataGridViewDataErrorEventHandler)(Events [DataErrorEvent]);
2860                         if (eh != null) {
2861                                 eh (this, e);
2862                         }
2863                         else {
2864                                 if (displayErrorDialogIfNoHandler) {
2865                                         /////////////////////////////////// ERROR DIALOG //////////////////////////////////7
2866                                 }
2867                         }
2868                 }
2869                 protected virtual void OnDataMemberChanged (EventArgs e) {
2870                         EventHandler eh = (EventHandler)(Events [DataMemberChangedEvent]);
2871                         if (eh != null)
2872                                 eh (this, e);
2873                 }
2874
2875                 protected virtual void OnDataSourceChanged (EventArgs e) {
2876                         EventHandler eh = (EventHandler)(Events [DataSourceChangedEvent]);
2877                         if (eh != null)
2878                                 eh (this, e);
2879                 }
2880
2881                 protected virtual void OnDefaultCellStyleChanged (EventArgs e) {
2882                         EventHandler eh = (EventHandler)(Events [DefaultCellStyleChangedEvent]);
2883                         if (eh != null)
2884                                 eh (this, e);
2885                 }
2886
2887                 protected virtual void OnDefaultValuesNeeded (DataGridViewRowEventArgs e) {
2888                         DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [DefaultValuesNeededEvent]);
2889                         if (eh != null)
2890                                 eh (this, e);
2891                 }
2892
2893                 protected override void OnDoubleClick (EventArgs e) {
2894                         base.OnDoubleClick(e);
2895                 }
2896
2897                 protected virtual void OnEditingControlShowing (DataGridViewEditingControlShowingEventArgs e) {
2898                         DataGridViewEditingControlShowingEventHandler eh = (DataGridViewEditingControlShowingEventHandler)(Events [EditingControlShowingEvent]);
2899                         if (eh != null)
2900                                 eh (this, e);
2901                 }
2902
2903                 protected virtual void OnEditModeChanged (EventArgs e)
2904                 {
2905                         EventHandler eh = (EventHandler)(Events [EditModeChangedEvent]);
2906                         if (eh != null)
2907                                 eh (this, e);
2908                 }
2909
2910                 protected override void OnEnabledChanged (EventArgs e)
2911                 {
2912                         base.OnEnabledChanged(e);
2913                 }
2914
2915                 protected override void OnEnter (EventArgs e )
2916                 {
2917                         base.OnEnter(e);
2918                 }
2919
2920                 protected override void OnGotFocus(EventArgs e)
2921                 {
2922                         base.OnGotFocus (e);
2923                 }
2924
2925                 protected override void OnFontChanged (EventArgs e)
2926                 {
2927                         base.OnFontChanged(e);
2928                 }
2929
2930                 protected override void OnForeColorChanged (EventArgs e)
2931                 {
2932                         base.OnForeColorChanged(e);
2933                 }
2934
2935                 protected virtual void OnGridColorChanged (EventArgs e)
2936                 {
2937                         EventHandler eh = (EventHandler)(Events [GridColorChangedEvent]);
2938                         if (eh != null)
2939                                 eh (this, e);
2940                 }
2941
2942                 protected override void OnHandleCreated (EventArgs e)
2943                 {
2944                         base.OnHandleCreated(e);
2945                 }
2946
2947                 protected override void OnHandleDestroyed(EventArgs e)
2948                 {
2949                         base.OnHandleDestroyed (e);
2950                 }
2951
2952                 [EditorBrowsable (EditorBrowsableState.Advanced)]
2953                 protected override void OnKeyDown (KeyEventArgs e)
2954                 {
2955                         base.OnKeyDown(e);
2956                 }
2957
2958                 [EditorBrowsable (EditorBrowsableState.Advanced)]
2959                 protected override void OnKeyPress (KeyPressEventArgs e)
2960                 {
2961                         base.OnKeyPress(e);
2962                 }
2963
2964                 [EditorBrowsable (EditorBrowsableState.Advanced)]
2965                 protected override void OnKeyUp (KeyEventArgs e)
2966                 {
2967                         base.OnKeyUp(e);
2968                 }
2969
2970                 protected override void OnLayout (LayoutEventArgs e)
2971                 {
2972                         base.OnLayout(e);
2973                 }
2974
2975                 protected override void OnLeave (EventArgs e)
2976                 {
2977                         base.OnLeave(e);
2978                 }
2979
2980                 protected override void OnLostFocus(EventArgs e)
2981                 {
2982                         base.OnLostFocus (e);
2983                 }
2984
2985                 protected override void OnMouseClick (MouseEventArgs e)
2986                 {
2987                         base.OnMouseClick(e);
2988                         //Console.WriteLine("Mouse: Clicks: {0}; Delta: {1}; X: {2}; Y: {3};", e.Clicks, e.Delta, e.X, e.Y);
2989                 }
2990
2991                 protected override void OnMouseDoubleClick (MouseEventArgs e)
2992                 {
2993                         base.OnMouseDoubleClick(e);
2994                 }
2995
2996                 protected override void OnMouseDown (MouseEventArgs e)
2997                 {
2998                         base.OnMouseDown(e);
2999                         //Console.WriteLine("Mouse: Clicks: {0}; Delta: {1}; X: {2}; Y: {3};", e.Clicks, e.Delta, e.X, e.Y);
3000                         HitTestInfo hitTest = HitTest(e.X, e.Y);
3001                         //Console.WriteLine("HitTest: Column: {0}; Row: {1};", hitTest.ColumnIndex, hitTest.RowIndex);
3002                         if (hitTest.RowIndex < 0 || hitTest.ColumnIndex < 0) {
3003                                 return;
3004                         }
3005                         OnCellClick(new DataGridViewCellEventArgs(hitTest.ColumnIndex, hitTest.RowIndex));
3006                         DataGridViewRow row = rows[hitTest.RowIndex];
3007                         DataGridViewCell cell = row.Cells[hitTest.ColumnIndex];
3008                         ClearSelection(0, 0, false);
3009                         switch (selectionMode) {
3010                                 case DataGridViewSelectionMode.FullRowSelect:
3011                                         row.Selected = true;
3012                                         break;
3013                                 case DataGridViewSelectionMode.FullColumnSelect:
3014                                         //////////////////
3015                                         break;
3016                                 default:
3017                                         cell.Selected = true;
3018                                         break;
3019                         }
3020                         if (cell == currentCell) {
3021                                 currentCell.SetIsInEditMode(true);
3022                                 OnCellBeginEdit(new DataGridViewCellCancelEventArgs(currentCell.ColumnIndex, currentCell.RowIndex));
3023                                 Invalidate();
3024                                 return;
3025                         }
3026                         if (currentCell != null) {
3027                                 if (currentCell.IsInEditMode) {
3028                                         currentCell.SetIsInEditMode(false);
3029                                         currentCell.DetachEditingControl();
3030                                         OnCellEndEdit(new DataGridViewCellEventArgs(currentCell.ColumnIndex, currentCell.RowIndex));
3031                                 }
3032                                 OnCellLeave(new DataGridViewCellEventArgs(currentCell.ColumnIndex, currentCell.RowIndex));
3033                         }
3034                         currentCell = cell;
3035                         OnCurrentCellChanged(EventArgs.Empty);
3036                         OnCellEnter(new DataGridViewCellEventArgs(cell.ColumnIndex, cell.RowIndex));
3037                         if (editMode == DataGridViewEditMode.EditOnEnter) {
3038                                 currentCell.SetIsInEditMode(true);
3039                                 OnCellBeginEdit(new DataGridViewCellCancelEventArgs(currentCell.ColumnIndex, currentCell.RowIndex));
3040                         }
3041                         Invalidate();
3042                         return;
3043                 }
3044
3045                 protected override void OnMouseEnter (EventArgs e)
3046                 {
3047                         base.OnMouseEnter(e);
3048                 }
3049
3050                 protected override void OnMouseLeave (EventArgs e)
3051                 {
3052                         base.OnMouseLeave(e);
3053                 }
3054
3055                 protected override void OnMouseMove (MouseEventArgs e)
3056                 {
3057                         base.OnMouseMove(e);
3058                 }
3059
3060                 protected override void OnMouseUp (MouseEventArgs e)
3061                 {
3062                         base.OnMouseUp(e);
3063                 }
3064
3065                 protected override void OnMouseWheel (MouseEventArgs e)
3066                 {
3067                         base.OnMouseWheel(e);
3068                 }
3069
3070                 protected virtual void OnMultiSelectChanged (EventArgs e)
3071                 {
3072                         EventHandler eh = (EventHandler)(Events [MultiSelectChangedEvent]);
3073                         if (eh != null) eh (this, e);
3074                 }
3075
3076                 protected virtual void OnNewRowNeeded (DataGridViewRowEventArgs e) {
3077                         DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [NewRowNeededEvent]);
3078                         if (eh != null) eh (this, e);
3079                 }
3080
3081                 protected override void OnPaint (PaintEventArgs e) {
3082                         base.OnPaint(e);
3083                         //Console.WriteLine("DataGridView.OnPaint-ClipRectangle: {0};", e.ClipRectangle);
3084                         Rectangle bounds = ClientRectangle; //e.ClipRectangle;
3085                         e.Graphics.FillRectangle(new SolidBrush(backgroundColor), bounds);
3086                         Pen pen = new Pen(gridColor);
3087                         pen.Width = 1;
3088                         int i = 0;
3089                         ArrayList sortedColumns = columns.ColumnDisplayIndexSortedArrayList;
3090                         bounds.Y = -verticalScrollingOffset;
3091                         bounds.X = -horizontalScrollingOffset;
3092                         gridWidth = 0;
3093                         foreach (DataGridViewColumn col in sortedColumns) {
3094                                 gridWidth += col.Width;
3095                         }
3096                         if (columnHeadersVisible) {
3097                                 Rectangle headerBounds = bounds;
3098                                 if (rowHeadersVisible) {
3099                                         headerBounds.X += rowHeadersWidth;
3100                                 }
3101                                 headerBounds.Height = columnHeadersHeight;
3102                                 int j = 0;
3103                                 foreach (DataGridViewColumn col in sortedColumns) {
3104                                         headerBounds.Width = col.Width;
3105                                         DataGridViewCell cell = col.HeaderCell;
3106                                         DataGridViewCellStyle style = columnHeadersDefaultCellStyle;
3107                                         DataGridViewAdvancedBorderStyle intermediateBorderStyle = (DataGridViewAdvancedBorderStyle) ((ICloneable)this.AdvancedColumnHeadersBorderStyle).Clone();
3108                                         DataGridViewAdvancedBorderStyle borderStyle = AdjustColumnHeaderBorderStyle(this.AdvancedColumnHeadersBorderStyle, intermediateBorderStyle, j == 0, j == columns.Count - 1);
3109                                         cell.InternalPaint(e.Graphics, e.ClipRectangle, headerBounds, cell.RowIndex, cell.State, cell.Value, cell.FormattedValue, cell.ErrorText, style, borderStyle, DataGridViewPaintParts.All);
3110                                         headerBounds.X += col.Width;
3111                                         j++;
3112                                 }
3113                                 bounds.Y += columnHeadersHeight;
3114                         }
3115                         gridHeight = 0;
3116                         foreach (DataGridViewRow row in rows) {
3117                                 gridHeight += row.Height;
3118                                 if (rowHeadersVisible) {
3119                                         Rectangle rowHeaderBounds = bounds;
3120                                         rowHeaderBounds.Height = row.Height;
3121                                         rowHeaderBounds.Width = rowHeadersWidth;
3122                                         DataGridViewCell cell = row.HeaderCell;
3123                                         DataGridViewCellStyle style = rowHeadersDefaultCellStyle;
3124                                         DataGridViewAdvancedBorderStyle intermediateBorderStyle = (DataGridViewAdvancedBorderStyle) ((ICloneable)this.AdvancedRowHeadersBorderStyle).Clone();
3125                                         DataGridViewAdvancedBorderStyle borderStyle = cell.AdjustCellBorderStyle(this.AdvancedRowHeadersBorderStyle, intermediateBorderStyle, true, true, false, cell.RowIndex == 0);
3126                                         cell.InternalPaint(e.Graphics, e.ClipRectangle, rowHeaderBounds, cell.RowIndex, cell.State, cell.Value, cell.FormattedValue, cell.ErrorText, style, borderStyle, DataGridViewPaintParts.All);
3127                                         //e.Graphics.FillRectangle(new SolidBrush(rowHeadersDefaultCellStyle.BackColor), rowHeadersBounds);
3128                                         bounds.X += rowHeadersWidth;
3129                                 }
3130                                 bounds.Height = row.Height;
3131                                 for (int j = 0; j < sortedColumns.Count; j++) {
3132                                         DataGridViewColumn col = (DataGridViewColumn) sortedColumns[j];
3133                                         foreach (DataGridViewCell cell in row.Cells) {
3134                                                 if (cell.ColumnIndex == col.Index) {
3135                                                         bounds.Width = col.Width;
3136                                                         cell.SetSize(new Size(bounds.Width, bounds.Height));
3137                                                         DataGridViewCellStyle style = cell.InheritedStyle;
3138                                                         if (cell == currentCell && cell.IsInEditMode) {
3139                                                                 cell.InitializeEditingControl(cell.RowIndex, cell.FormattedValue, style);
3140                                                                 cell.PositionEditingControl(true, true, bounds, e.ClipRectangle, style, false, false, (columns[currentCell.ColumnIndex].DisplayIndex == 0), (currentCell.RowIndex == 0));
3141                                                         }
3142                                                         else {
3143                                                                 DataGridViewAdvancedBorderStyle intermediateBorderStyle = (DataGridViewAdvancedBorderStyle) ((ICloneable)this.AdvancedCellBorderStyle).Clone();
3144                                                                 DataGridViewAdvancedBorderStyle borderStyle = cell.AdjustCellBorderStyle(this.AdvancedCellBorderStyle, intermediateBorderStyle, true, true, j == 0, cell.RowIndex == 0);
3145                                                                 OnCellFormatting(new DataGridViewCellFormattingEventArgs(cell.ColumnIndex, cell.RowIndex, cell.Value, cell.FormattedValueType, style));
3146                                                                 DataGridViewCellPaintingEventArgs args = new DataGridViewCellPaintingEventArgs (this, e.Graphics, e.ClipRectangle, bounds, cell.RowIndex, cell.ColumnIndex, cell.State, cell.Value, cell.FormattedValue, cell.ErrorText, style, borderStyle, DataGridViewPaintParts.All);
3147                                                                 OnCellPainting(args);
3148                                                                 if (!args.Handled) {
3149                                                                         cell.InternalPaint(e.Graphics, e.ClipRectangle, bounds, cell.RowIndex, cell.State, cell.Value, cell.FormattedValue, cell.ErrorText, style, borderStyle, DataGridViewPaintParts.All);
3150                                                                 }
3151                                                         }
3152                                                         bounds.X += bounds.Width;
3153                                                 }
3154                                         }
3155                                 }
3156                                 bounds.Y += bounds.Height;
3157                                 bounds.X = -horizontalScrollingOffset;
3158                                 i++;
3159                         }
3160                         if (rowHeadersVisible) {
3161                                 gridWidth += rowHeadersWidth;
3162                         }
3163                         if (columnHeadersVisible) {
3164                                 gridHeight += columnHeadersHeight;
3165                         }
3166                         horizontalScrollBar.Visible = false;
3167                         verticalScrollBar.Visible = false;
3168                         if (AutoSize) {
3169                                 if (gridWidth > Size.Width || gridHeight > Size.Height) {
3170                                         Size = new Size(gridWidth, gridHeight);
3171                                 }
3172                         }
3173                         else {
3174                                 if (gridWidth > Size.Width) {
3175                                         horizontalScrollBar.Visible = true;
3176                                 }
3177                                 if (gridHeight > Size.Height) {
3178                                         verticalScrollBar.Visible = true;
3179                                 }
3180                                 if (horizontalScrollBar.Visible && (gridHeight + horizontalScrollBar.Height) > Size.Height) {
3181                                         verticalScrollBar.Visible = true;
3182                                 }
3183                                 if (verticalScrollBar.Visible && (gridWidth + verticalScrollBar.Width) > Size.Width) {
3184                                         horizontalScrollBar.Visible = true;
3185                                 }
3186                                 if (horizontalScrollBar.Visible) {
3187                                         horizontalScrollBar.Minimum = 0;
3188                                         if (verticalScrollBar.Visible) {
3189                                                 horizontalScrollBar.Maximum = gridWidth - ClientRectangle.Width + verticalScrollBar.Width;
3190                                         }
3191                                         else {
3192                                                 horizontalScrollBar.Maximum = gridWidth - ClientRectangle.Width;
3193                                         }
3194                                         horizontalScrollBar.LargeChange = horizontalScrollBar.Maximum / 10;
3195                                         horizontalScrollBar.SmallChange = horizontalScrollBar.Maximum / 20;
3196                                 }
3197                                 if (verticalScrollBar.Visible) {
3198                                         verticalScrollBar.Minimum = 0;
3199                                         if (horizontalScrollBar.Visible) {
3200                                                 verticalScrollBar.Maximum = gridHeight - ClientRectangle.Height + horizontalScrollBar.Height;
3201                                         }
3202                                         else {
3203                                                 verticalScrollBar.Maximum = gridHeight - ClientRectangle.Height;
3204                                         }
3205                                         verticalScrollBar.LargeChange = verticalScrollBar.Maximum / 10;
3206                                         verticalScrollBar.SmallChange = verticalScrollBar.Maximum / 20;
3207                                 }
3208                         }
3209                         if (horizontalScrollBar.Visible && !this.Controls.Contains(horizontalScrollBar)) {
3210                                 this.Controls.Add(horizontalScrollBar);
3211                         }
3212                         else if (!horizontalScrollBar.Visible && this.Controls.Contains(horizontalScrollBar)) {
3213                                 this.Controls.Remove(horizontalScrollBar);
3214                         }
3215                         if (verticalScrollBar.Visible && !this.Controls.Contains(verticalScrollBar)) {
3216                                 this.Controls.Add(verticalScrollBar);
3217                         }
3218                         else if (!verticalScrollBar.Visible && this.Controls.Contains(verticalScrollBar)) {
3219                                 this.Controls.Remove(verticalScrollBar);
3220                         }
3221                 }
3222
3223                 protected virtual void OnReadOnlyChanged (EventArgs e) {
3224                         EventHandler eh = (EventHandler)(Events [ReadOnlyChangedEvent]);
3225                         if (eh != null)
3226                                 eh (this, e);
3227                 }
3228
3229                 protected override void OnResize (EventArgs e) {
3230                         base.OnResize(e);
3231                         horizontalScrollingOffset = ((gridWidth - Size.Width) > 0)? (gridWidth - Size.Width) : 0;
3232                         verticalScrollingOffset = ((gridHeight - Size.Height) > 0)? (gridHeight - Size.Height) : 0;
3233
3234                 }
3235
3236                 protected override void OnRightToLeftChanged (EventArgs e) {
3237                         base.OnRightToLeftChanged(e);
3238                 }
3239
3240                 // In MSDN2 documentation there's no internal here
3241                 protected internal virtual void OnRowContextMenuStripChanged (DataGridViewRowEventArgs e)
3242                 {
3243                         DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowContextMenuStripChangedEvent]);
3244                         if (eh != null) eh (this, e);
3245                 }
3246
3247                 protected virtual void OnRowContextMenuStripNeeded (DataGridViewRowContextMenuStripNeededEventArgs e)
3248                 {
3249                         DataGridViewRowContextMenuStripNeededEventHandler eh = (DataGridViewRowContextMenuStripNeededEventHandler)(Events [RowContextMenuStripNeededEvent]);
3250                         if (eh != null) eh (this, e);
3251                 }
3252
3253                 protected internal virtual void OnRowDefaultCellStyleChanged (DataGridViewRowEventArgs e)
3254                 {
3255                         DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowDefaultCellStyleChangedEvent]);
3256                         if (eh != null) eh (this, e);
3257                 }
3258
3259                 protected virtual void OnRowDirtyStateNeeded (QuestionEventArgs e)
3260                 {
3261                         QuestionEventHandler eh = (QuestionEventHandler)(Events [RowDirtyStateNeededEvent]);
3262                         if (eh != null) eh (this, e);
3263                 }
3264
3265                 protected virtual void OnRowDividerDoubleClick (DataGridViewRowDividerDoubleClickEventArgs e)
3266                 {
3267                         DataGridViewRowDividerDoubleClickEventHandler eh = (DataGridViewRowDividerDoubleClickEventHandler)(Events [RowDividerDoubleClickEvent]);
3268                         if (eh != null) eh (this, e);
3269                 }
3270
3271                 protected virtual void OnRowDividerHeightChanged (DataGridViewRowEventArgs e)
3272                 {
3273                         DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowDividerHeightChangedEvent]);
3274                         if (eh != null) eh (this, e);
3275                 }
3276
3277                 protected virtual void OnRowEnter (DataGridViewCellEventArgs e)
3278                 {
3279                         DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [RowEnterEvent]);
3280                         if (eh != null) eh (this, e);
3281                 }
3282
3283                 protected internal virtual void OnRowErrorTextChanged (DataGridViewRowEventArgs e)
3284                 {
3285                         DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowErrorTextChangedEvent]);
3286                         if (eh != null) eh (this, e);
3287                 }
3288
3289                 protected virtual void OnRowErrorTextNeeded (DataGridViewRowErrorTextNeededEventArgs e)
3290                 {
3291                         DataGridViewRowErrorTextNeededEventHandler eh = (DataGridViewRowErrorTextNeededEventHandler)(Events [RowErrorTextNeededEvent]);
3292                         if (eh != null) eh (this, e);
3293                 }
3294
3295                 protected internal virtual void OnRowHeaderCellChanged (DataGridViewRowEventArgs e)
3296                 {
3297                         DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowHeaderCellChangedEvent]);
3298                         if (eh != null) eh (this, e);
3299                 }
3300
3301                 protected virtual void OnRowHeaderMouseClick (DataGridViewCellMouseEventArgs e)
3302                 {
3303                         DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [RowHeaderMouseClickEvent]);
3304                         if (eh != null) eh (this, e);
3305                 }
3306
3307                 protected virtual void OnRowHeaderMouseDoubleClick (DataGridViewCellMouseEventArgs e)
3308                 {
3309                         DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [RowHeaderMouseDoubleClickEvent]);
3310                         if (eh != null) eh (this, e);
3311                 }
3312
3313                 protected virtual void OnRowHeadersBorderStyleChanged (EventArgs e)
3314                 {
3315                         EventHandler eh = (EventHandler)(Events [RowHeadersBorderStyleChangedEvent]);
3316                         if (eh != null) eh (this, e);
3317                 }
3318
3319                 protected virtual void OnRowHeadersDefaultCellStyleChanged (EventArgs e)
3320                 {
3321                         EventHandler eh = (EventHandler)(Events [RowHeadersDefaultCellStyleChangedEvent]);
3322                         if (eh != null) eh (this, e);
3323                 }
3324
3325                 protected virtual void OnRowHeadersWidthChanged (EventArgs e)
3326                 {
3327                         EventHandler eh = (EventHandler)(Events [RowHeadersWidthChangedEvent]);
3328                         if (eh != null) eh (this, e);
3329                 }
3330
3331                 protected virtual void OnRowHeadersWidthSizeModeChanged (DataGridViewAutoSizeModeEventArgs e)
3332                 {
3333                         DataGridViewAutoSizeModeEventHandler eh = (DataGridViewAutoSizeModeEventHandler)(Events [RowHeadersWidthSizeModeChangedEvent]);
3334                         if (eh != null) eh (this, e);
3335                 }
3336
3337                 protected internal virtual void OnRowHeightChanged (DataGridViewRowEventArgs e)
3338                 {
3339                         DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowHeightChangedEvent]);
3340                         if (eh != null) eh (this, e);
3341                 }
3342
3343                 protected virtual void OnRowHeightInfoNeeded (DataGridViewRowHeightInfoNeededEventArgs e)
3344                 {
3345                         DataGridViewRowHeightInfoNeededEventHandler eh = (DataGridViewRowHeightInfoNeededEventHandler)(Events [RowHeightInfoNeededEvent]);
3346                         if (eh != null) eh (this, e);
3347                 }
3348
3349                 protected virtual void OnRowHeightInfoPushed (DataGridViewRowHeightInfoPushedEventArgs e)
3350                 {
3351                         DataGridViewRowHeightInfoPushedEventHandler eh = (DataGridViewRowHeightInfoPushedEventHandler)(Events [RowHeightInfoPushedEvent]);
3352                         if (eh != null) eh (this, e);
3353                 }
3354
3355                 protected virtual void OnRowLeave (DataGridViewCellEventArgs e)
3356                 {
3357                         DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [RowLeaveEvent]);
3358                         if (eh != null) eh (this, e);
3359                 }
3360
3361                 protected internal virtual void OnRowMinimumHeightChanged (DataGridViewRowEventArgs e)
3362                 {
3363                         DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowMinimumHeightChangedEvent]);
3364                         if (eh != null) eh (this, e);
3365                 }
3366
3367                 protected internal virtual void OnRowPostPaint (DataGridViewRowPostPaintEventArgs e)
3368                 {
3369                         DataGridViewRowPostPaintEventHandler eh = (DataGridViewRowPostPaintEventHandler)(Events [RowPostPaintEvent]);
3370                         if (eh != null) eh (this, e);
3371                 }
3372
3373                 protected internal virtual void OnRowPrePaint (DataGridViewRowPrePaintEventArgs e)
3374                 {
3375                         DataGridViewRowPrePaintEventHandler eh = (DataGridViewRowPrePaintEventHandler)(Events [RowPrePaintEvent]);
3376                         if (eh != null) eh (this, e);
3377                 }
3378
3379                 protected internal virtual void OnRowsAdded (DataGridViewRowsAddedEventArgs e)
3380                 {
3381                         DataGridViewRowsAddedEventHandler eh = (DataGridViewRowsAddedEventHandler)(Events [RowsAddedEvent]);
3382                         if (eh != null) eh (this, e);
3383                 }
3384
3385                 protected virtual void OnRowsDefaultCellStyleChanged (EventArgs e)
3386                 {
3387                         EventHandler eh = (EventHandler)(Events [RowsDefaultCellStyleChangedEvent]);
3388                         if (eh != null) eh (this, e);
3389                 }
3390
3391                 protected internal virtual void OnRowsRemoved (DataGridViewRowsRemovedEventArgs e)
3392                 {
3393                         DataGridViewRowsRemovedEventHandler eh = (DataGridViewRowsRemovedEventHandler)(Events [RowsRemovedEvent]);
3394                         if (eh != null) eh (this, e);
3395                 }
3396
3397                 protected internal virtual void OnRowStateChanged (int rowIndex, DataGridViewRowStateChangedEventArgs e)
3398                 {
3399                         DataGridViewRowStateChangedEventHandler eh = (DataGridViewRowStateChangedEventHandler)(Events [RowStateChangedEvent]);
3400                         if (eh != null) eh (this, e);
3401                 }
3402
3403                 protected virtual void OnRowUnshared (DataGridViewRowEventArgs e)
3404                 {
3405                         DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowUnsharedEvent]);
3406                         if (eh != null) eh (this, e);
3407                 }
3408
3409                 protected virtual void OnRowValidated (DataGridViewCellEventArgs e)
3410                 {
3411                         DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [RowValidatedEvent]);
3412                         if (eh != null) eh (this, e);
3413                 }
3414
3415                 protected virtual void OnRowValidating (DataGridViewCellCancelEventArgs e)
3416                 {
3417                         DataGridViewCellCancelEventHandler eh = (DataGridViewCellCancelEventHandler)(Events [RowValidatingEvent]);
3418                         if (eh != null) eh (this, e);
3419                 }
3420
3421                 protected virtual void OnScroll (ScrollEventArgs e)
3422                 {
3423                         ScrollEventHandler eh = (ScrollEventHandler)(Events [ScrollEvent]);
3424                         if (eh != null) eh (this, e);
3425                 }
3426
3427                 protected virtual void OnSelectionChanged (EventArgs e)
3428                 {
3429                         EventHandler eh = (EventHandler)(Events [SelectionChangedEvent]);
3430                         if (eh != null) eh (this, e);
3431                 }
3432
3433                 protected virtual void OnSortCompare (DataGridViewSortCompareEventArgs e) {
3434                         DataGridViewSortCompareEventHandler eh = (DataGridViewSortCompareEventHandler)(Events [SortCompareEvent]);
3435                         if (eh != null) eh (this, e);
3436                 }
3437
3438                 protected virtual void OnSorted (EventArgs e)
3439                 {
3440                         EventHandler eh = (EventHandler)(Events [SortedEvent]);
3441                         if (eh != null) eh (this, e);
3442                 }
3443
3444                 protected virtual void OnUserAddedRow (DataGridViewRowEventArgs e)
3445                 {
3446                         DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [UserAddedRowEvent]);
3447                         if (eh != null) eh (this, e);
3448                 }
3449
3450                 protected virtual void OnUserDeletedRow (DataGridViewRowEventArgs e)
3451                 {
3452                         DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [UserDeletedRowEvent]);
3453                         if (eh != null) eh (this, e);
3454
3455                 }
3456
3457                 protected virtual void OnUserDeletingRow (DataGridViewRowCancelEventArgs e)
3458                 {
3459                         DataGridViewRowCancelEventHandler eh = (DataGridViewRowCancelEventHandler)(Events [UserDeletingRowEvent]);
3460                         if (eh != null) eh (this, e);
3461                 }
3462
3463                 protected override void OnValidating (CancelEventArgs e)
3464                 {
3465                         base.OnValidating(e);
3466                 }
3467
3468                 protected override void OnVisibleChanged (EventArgs e)
3469                 {
3470                         base.OnVisibleChanged(e);
3471                 }
3472
3473                 protected virtual void PaintBackground (Graphics graphics, Rectangle clipBounds, Rectangle gridBounds)
3474                 {
3475                 }
3476
3477                 protected bool ProcessAKey (Keys keyData)
3478                 {
3479                         throw new NotImplementedException();
3480                 }
3481
3482                 protected virtual bool ProcessDataGridViewKey (KeyEventArgs e)
3483                 {
3484                         throw new NotImplementedException();
3485                 }
3486
3487                 protected bool ProcessDeleteKey (Keys keyData)
3488                 {
3489                         throw new NotImplementedException();
3490                 }
3491
3492                 protected override bool ProcessDialogKey (Keys keyData)
3493                 {
3494                         return base.ProcessDialogKey(keyData);
3495                         //throw new NotImplementedException();
3496                 }
3497
3498                 protected bool ProcessDownKey (Keys keyData) {
3499                         throw new NotImplementedException();
3500                 }
3501
3502                 protected bool ProcessEndKey (Keys keyData) {
3503                         throw new NotImplementedException();
3504                 }
3505
3506                 protected bool ProcessEnterKey (Keys keyData) {
3507                         throw new NotImplementedException();
3508                 }
3509
3510                 protected bool ProcessEscapeKey (Keys keyData) {
3511                         throw new NotImplementedException();
3512                 }
3513
3514                 protected bool ProcessF2Key (Keys keyData) {
3515                         throw new NotImplementedException();
3516                 }
3517
3518                 protected bool ProcessHomeKey (Keys keyData) {
3519                         throw new NotImplementedException();
3520                 }
3521
3522                 protected bool ProcessInsertKey (Keys keyData) {
3523                         throw new NotImplementedException();
3524                 }
3525
3526                 protected override bool ProcessKeyEventArgs (ref Message m) {
3527                         return base.ProcessKeyEventArgs(ref m);
3528                         //throw new NotImplementedException();
3529                 }
3530
3531                 protected override bool ProcessKeyPreview (ref Message m) {
3532                         return base.ProcessKeyPreview(ref m);
3533                         //throw new NotImplementedException();
3534                 }
3535
3536                 protected bool ProcessLeftKey (Keys keyData) {
3537                         throw new NotImplementedException();
3538                 }
3539
3540                 protected bool ProcessNextKey (Keys keyData) {
3541                         // PAGE DOWN
3542                         throw new NotImplementedException();
3543                 }
3544
3545                 protected bool ProcessPriorKey (Keys keyData) {
3546                         // PAGE UP
3547                         throw new NotImplementedException();
3548                 }
3549
3550                 protected bool ProcessRightKey (Keys keyData) {
3551                         throw new NotImplementedException();
3552                 }
3553
3554                 protected bool ProcessSpaceKey (Keys keyData) {
3555                         throw new NotImplementedException();
3556                 }
3557
3558                 protected bool ProcessTabKey (Keys keyData) {
3559                         throw new NotImplementedException();
3560                 }
3561
3562                 protected bool ProcessUpKey (Keys keyData) {
3563                         throw new NotImplementedException();
3564                 }
3565
3566                 protected bool ProcessZeroKey (Keys keyData) {
3567                         throw new NotImplementedException();
3568                 }
3569
3570                 protected override void SetBoundsCore (int x, int y, int width, int height, BoundsSpecified specified) {
3571                         base.SetBoundsCore(x, y, width, height, specified);
3572                 }
3573
3574                 protected virtual bool SetCurrentCellAddressCore (int columnIndex, int rowIndex, bool setAnchorCellAddress, bool validateCurrentCell, bool throughMouseClick) {
3575                         throw new NotImplementedException();
3576                 }
3577
3578                 protected virtual void SetSelectedCellCore (int columnIndex, int rowIndex, bool selected) {
3579                         throw new NotImplementedException();
3580                 }
3581
3582                 protected virtual void SetSelectedColumnCore (int columnIndex, bool selected) {
3583                         throw new NotImplementedException();
3584                 }
3585
3586                 protected virtual void SetSelectedRowCore (int rowIndex, bool selected) {
3587                         throw new NotImplementedException();
3588                 }
3589
3590                 protected override void WndProc (ref Message m) {
3591                         base.WndProc(ref m);
3592                 }
3593
3594                 void IDropTarget.OnDragDrop (DragEventArgs e)
3595                 {
3596                         throw new NotImplementedException ();
3597                 }
3598
3599                 void IDropTarget.OnDragEnter (DragEventArgs e)
3600                 {
3601                         throw new NotImplementedException ();
3602                 }
3603
3604                 void IDropTarget.OnDragLeave (EventArgs e)
3605                 {
3606                         throw new NotImplementedException ();
3607                 }
3608
3609                 void IDropTarget.OnDragOver (DragEventArgs e)
3610                 {
3611                         throw new NotImplementedException ();
3612                 }
3613
3614                 internal void InternalOnCellClick (DataGridViewCellEventArgs e) {
3615                         OnCellClick(e);
3616                 }
3617
3618                 internal void InternalOnCellContentClick (DataGridViewCellEventArgs e) {
3619                         OnCellContentClick(e);
3620                 }
3621
3622                 internal void InternalOnCellContentDoubleClick (DataGridViewCellEventArgs e) {
3623                         OnCellContentDoubleClick(e);
3624                 }
3625
3626                 internal void InternalOnCellValueChanged (DataGridViewCellEventArgs e) {
3627                         OnCellValueChanged(e);
3628                 }
3629
3630                 internal void InternalOnDataError (DataGridViewDataErrorEventArgs e) {
3631                         /////////////// false? ////////////
3632                         OnDataError(false, e);
3633                 }
3634
3635                 internal void InternalOnMouseWheel (MouseEventArgs e) {
3636                         OnMouseWheel(e);
3637                 }
3638
3639                 internal void OnHScrollBarScroll (object sender, ScrollEventArgs e) {
3640                         horizontalScrollingOffset = e.NewValue;
3641                         Invalidate();
3642                         OnScroll(e);
3643                 }
3644
3645                 internal void OnVScrollBarScroll (object sender, ScrollEventArgs e) {
3646                         verticalScrollingOffset = e.NewValue;
3647                         Invalidate();
3648                         OnScroll(e);
3649                 }
3650
3651                 internal void RaiseCellStyleChanged (DataGridViewCellEventArgs e) {
3652                         OnCellStyleChanged(e);
3653                 }
3654
3655                 internal void OnColumnCollectionChanged (object sender, CollectionChangeEventArgs e) {
3656                         switch (e.Action) {
3657                                 case CollectionChangeAction.Add:
3658                                         OnColumnAdded(new DataGridViewColumnEventArgs(e.Element as DataGridViewColumn));
3659                                         break;
3660                                 case CollectionChangeAction.Remove:
3661                                         OnColumnRemoved(new DataGridViewColumnEventArgs(e.Element as DataGridViewColumn));
3662                                         break;
3663                                 case CollectionChangeAction.Refresh:
3664                                         break;
3665                         }
3666                 }
3667
3668                 private void BindIList (IList list) {
3669                         if (list is DataView) {
3670                                 DataView dataView = (DataView) list;
3671                                 DataTable table = dataView.Table;
3672                                 DataGridViewCell template = new DataGridViewTextBoxCell();
3673                                 foreach (DataColumn dataColumn in table.Columns) {
3674                                         DataGridViewColumn col = new DataGridViewColumn(template);
3675                                         col.Name = dataColumn.ColumnName;
3676                                         col.ValueType = dataColumn.DataType;
3677                                         columns.Add(col);
3678                                 }
3679                                 dataView.ListChanged += OnListChanged;
3680                         }
3681                         else if (list.Count > 0) {
3682                                 DataGridViewCell template = new DataGridViewTextBoxCell();
3683                                 foreach (PropertyDescriptor property in TypeDescriptor.GetProperties(list[0])) {
3684                                         DataGridViewColumn col = new DataGridViewColumn(template);
3685                                         col.Name = property.DisplayName;
3686                                         columns.Add(col);
3687                                 }
3688                         }
3689                         foreach (object element in list) {
3690                                 DataGridViewRow row = new DataGridViewRow();
3691                                 rows.InternalAdd(row);
3692                                 PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(element);
3693                                 foreach (PropertyDescriptor property in properties) {
3694                                         DataGridViewTextBoxCell cell = new DataGridViewTextBoxCell();
3695                                         cell.Value = property.GetValue(element);
3696                                         cell.ValueType = property.PropertyType;
3697                                         row.Cells.Add(cell);
3698                                 }
3699                         }
3700                 }
3701
3702                 private void BindIListSource (IListSource list) {
3703                         BindIList(list.GetList());
3704                 }
3705
3706                 private void BindIBindingList (IBindingList list) {
3707                         BindIList(list);
3708                 }
3709
3710                 private void BindIBindingListView (IBindingListView list) {
3711                         BindIList(list);
3712                 }
3713
3714                 private void OnListChanged (object sender, ListChangedEventArgs args) {
3715                         if (args.OldIndex >= 0) {
3716                         }
3717                         if (args.NewIndex >= 0) {
3718                                 object element = (sender as DataView)[args.NewIndex];
3719                                 DataGridViewRow row = new DataGridViewRow();
3720                                 rows.InternalAdd(row);
3721                                 PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(element);
3722                                 foreach (PropertyDescriptor property in properties) {
3723                                         DataGridViewTextBoxCell cell = new DataGridViewTextBoxCell();
3724                                         cell.Value = property.GetValue(element);
3725                                         cell.ValueType = property.PropertyType;
3726                                         row.Cells.Add(cell);
3727                                 }
3728                                 Invalidate();
3729                         }
3730                 }
3731
3732                 public sealed class HitTestInfo {
3733
3734                         public static readonly HitTestInfo Nowhere = new HitTestInfo(-1, -1, -1, -1, DataGridViewHitTestType.None);
3735
3736                         private int columnIndex;
3737                         private int columnX;
3738                         private int rowIndex;
3739                         private int rowY;
3740                         private DataGridViewHitTestType type;
3741
3742                         internal HitTestInfo (int columnIndex, int columnX, int rowIndex, int rowY, DataGridViewHitTestType type) {
3743                                 this.columnIndex = columnIndex;
3744                                 this.columnX = columnX;
3745                                 this.rowIndex = rowIndex;
3746                                 this.rowY = rowY;
3747                                 this.type = type;
3748                         }
3749
3750                         public int ColumnIndex {
3751                                 get { return columnIndex; }
3752                         }
3753
3754                         public int ColumnX {
3755                                 get { return columnX; }
3756                         }
3757
3758                         public int RowIndex {
3759                                 get { return rowIndex; }
3760                         }
3761
3762                         public int RowY {
3763                                 get { return rowY; }
3764                         }
3765
3766                         public DataGridViewHitTestType Type {
3767                                 get { return type; }
3768                         }
3769
3770                         public override bool Equals (object value) {
3771                                 if (value is HitTestInfo) {
3772                                         HitTestInfo aux = (HitTestInfo) value;
3773                                         if (aux.columnIndex == columnIndex && aux.columnX == columnX && aux.rowIndex == rowIndex && aux.rowY == rowY && aux.type == type) {
3774                                                 return true;
3775                                         }
3776                                 }
3777                                 return false;
3778                         }
3779
3780                         public override int GetHashCode () {
3781                                 return base.GetHashCode();
3782                         }
3783
3784                         public override string ToString () {
3785                                 return GetType().Name;
3786                         }
3787
3788                 }
3789
3790                 [ComVisibleAttribute(true)]
3791                 protected class DataGridViewAccessibleObject : ControlAccessibleObject {
3792
3793                         public DataGridViewAccessibleObject (DataGridView owner) : base (owner){
3794                         }
3795
3796                         public override AccessibleRole Role {
3797                                 get { return base.Role; }
3798                         }
3799
3800                         public override AccessibleObject GetChild (int index) {
3801                                 return base.GetChild(index);
3802                         }
3803
3804                         public override int GetChildCount () {
3805                                 return base.GetChildCount();
3806                         }
3807
3808                         public override AccessibleObject GetFocused () {
3809                                 return base.GetFocused();
3810                         }
3811
3812                         public override AccessibleObject GetSelected () {
3813                                 return base.GetSelected();
3814                         }
3815
3816                         public override AccessibleObject HitTest (int x, int y) {
3817                                 return base.HitTest(x, y);
3818                         }
3819
3820                         public override AccessibleObject Navigate( AccessibleNavigation navigationDirection) {
3821                                 return base.Navigate(navigationDirection);
3822                         }
3823
3824                 }
3825
3826         }
3827
3828 }
3829
3830 #endif