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:
9 // The above copyright notice and this permission notice shall be
10 // included in all copies or substantial portions of the Software.
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.
20 // Copyright (c) 2005 Novell, Inc. (http://www.novell.com)
23 // Pedro MartÃnez Juliá <pedromj@gmail.com>
29 using System.ComponentModel;
30 using System.Runtime.InteropServices;
32 using System.Reflection;
33 using System.Collections;
35 using System.Collections.Generic;
37 namespace System.Windows.Forms {
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
49 private DataGridViewAdvancedBorderStyle adjustedTopLeftHeaderBorderStyle;
50 private DataGridViewAdvancedBorderStyle advancedCellBorderStyle;
51 private DataGridViewAdvancedBorderStyle advancedColumnHeadersBorderStyle;
52 private DataGridViewAdvancedBorderStyle advancedRowHeadersBorderStyle;
53 private bool allowUserToAddRows;
54 private bool allowUserToDeleteRows;
55 private bool allowUserToOrderColumns;
56 private bool allowUserToResizeColumns;
57 private bool allowUserToResizeRows;
58 private DataGridViewCellStyle alternatingRowsDefaultCellStyle;
59 private Point anchor_cell;
60 private bool autoGenerateColumns;
61 private bool autoSize;
62 private DataGridViewAutoSizeColumnsMode autoSizeColumnsMode;
63 private DataGridViewAutoSizeRowsMode autoSizeRowsMode;
64 private Color backColor;
65 private Color backgroundColor;
66 private Image backgroundImage;
67 private BorderStyle borderStyle;
68 private DataGridViewCellBorderStyle cellBorderStyle;
69 private DataGridViewClipboardCopyMode clipboardCopyMode;
70 private DataGridViewHeaderBorderStyle columnHeadersBorderStyle;
71 private DataGridViewCellStyle columnHeadersDefaultCellStyle;
72 private int columnHeadersHeight;
73 private DataGridViewColumnHeadersHeightSizeMode columnHeadersHeightSizeMode;
74 private bool columnHeadersVisible;
75 private DataGridViewColumnCollection columns;
76 private DataGridViewCell currentCell;
77 private Point currentCellAddress;
78 private DataGridViewRow currentRow;
79 private string dataMember;
80 private object dataSource;
81 private DataGridViewCellStyle defaultCellStyle;
82 //private Control editingControl;
83 private DataGridViewEditMode editMode;
84 private bool enableHeadersVisualStyles = true;
85 private DataGridViewCell firstDisplayedCell;
86 private int firstDisplayedScrollingColumnHiddenWidth;
87 private int firstDisplayedScrollingColumnIndex;
88 private int firstDisplayedScrollingRowIndex;
89 private Color gridColor = Color.FromKnownColor(KnownColor.ControlDark);
90 private int horizontalScrollingOffset;
91 private DataGridViewCell hover_cell = null;
92 private bool isCurrentCellDirty;
93 //private bool isCurrentRowDirty;
94 private bool multiSelect;
95 private bool readOnly;
96 private DataGridViewHeaderBorderStyle rowHeadersBorderStyle;
97 private DataGridViewCellStyle rowHeadersDefaultCellStyle;
98 private bool rowHeadersVisible;
99 private int rowHeadersWidth;
100 private DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode;
101 private DataGridViewRowCollection rows;
102 private DataGridViewCellStyle rowsDefaultCellStyle;
103 private DataGridViewRow rowTemplate;
104 private ScrollBars scrollBars;
105 private DataGridViewSelectionMode selectionMode;
106 private bool showCellErrors;
107 private bool showCellToolTips;
108 private bool showEditingIcon;
109 private bool showRowErrors;
110 private DataGridViewColumn sortedColumn = null;
111 private SortOrder sortOrder;
112 private bool standardTab;
113 private DataGridViewHeaderCell topLeftHeaderCell;
114 private Cursor userSetCursor;
115 private int verticalScrollingOffset;
116 private bool virtualMode;
117 private HScrollBar horizontalScrollBar;
118 private VScrollBar verticalScrollBar;
119 private Control editingControl;
120 private bool new_row_commited = true;
122 // These are used to implement selection behaviour with SHIFT pressed.
123 private int selected_row = -1;
124 private int selected_column = -1;
126 // Stuff for error Tooltips
127 private Timer tooltip_timer;
128 private ToolTip tooltip_window;
129 private DataGridViewCell tooltip_currently_showing;
131 private DataGridViewSelectedRowCollection selected_rows;
132 private DataGridViewSelectedColumnCollection selected_columns;
133 private DataGridViewRow editing_row;
135 private int gridWidth;
136 private int gridHeight;
138 DataGridViewHeaderCell pressed_header_cell;
139 DataGridViewHeaderCell entered_header_cell;
141 // For column/row resizing via mouse
142 private bool column_resize_active = false;
143 private bool row_resize_active = false;
144 private int resize_band = -1;
145 private int resize_band_start = 0;
146 private int resize_band_delta = 0;
148 public DataGridView ()
150 SetStyle (ControlStyles.Opaque, true);
151 //SetStyle (ControlStyles.UserMouse, true);
152 SetStyle (ControlStyles.OptimizedDoubleBuffer, true);
154 adjustedTopLeftHeaderBorderStyle = new DataGridViewAdvancedBorderStyle();
155 adjustedTopLeftHeaderBorderStyle.All = DataGridViewAdvancedCellBorderStyle.Single;
156 advancedCellBorderStyle = new DataGridViewAdvancedBorderStyle();
157 advancedCellBorderStyle.All = DataGridViewAdvancedCellBorderStyle.Single;
158 advancedColumnHeadersBorderStyle = new DataGridViewAdvancedBorderStyle();
159 advancedColumnHeadersBorderStyle.All = DataGridViewAdvancedCellBorderStyle.Single;
160 advancedRowHeadersBorderStyle = new DataGridViewAdvancedBorderStyle();
161 advancedRowHeadersBorderStyle.All = DataGridViewAdvancedCellBorderStyle.Single;
162 alternatingRowsDefaultCellStyle = new DataGridViewCellStyle();
163 allowUserToAddRows = true;
164 allowUserToDeleteRows = true;
165 allowUserToOrderColumns = false;
166 allowUserToResizeColumns = true;
167 allowUserToResizeRows = true;
168 autoGenerateColumns = true;
169 autoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.None;
170 autoSizeRowsMode = DataGridViewAutoSizeRowsMode.None;
171 backColor = Control.DefaultBackColor;
172 backgroundColor = SystemColors.AppWorkspace;
173 borderStyle = BorderStyle.FixedSingle;
174 cellBorderStyle = DataGridViewCellBorderStyle.Single;
175 clipboardCopyMode = DataGridViewClipboardCopyMode.EnableWithAutoHeaderText;
176 columnHeadersBorderStyle = DataGridViewHeaderBorderStyle.Single;
177 columnHeadersDefaultCellStyle = new DataGridViewCellStyle();
178 columnHeadersDefaultCellStyle.BackColor = SystemColors.Control;
179 columnHeadersDefaultCellStyle.ForeColor = SystemColors.WindowText;
180 columnHeadersDefaultCellStyle.SelectionBackColor = SystemColors.Highlight;
181 columnHeadersDefaultCellStyle.SelectionForeColor = SystemColors.HighlightText;
182 columnHeadersDefaultCellStyle.Font = this.Font;
183 columnHeadersDefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleLeft;
184 columnHeadersDefaultCellStyle.WrapMode = DataGridViewTriState.True;
185 columnHeadersHeight = 23;
186 columnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.EnableResizing;
187 columnHeadersVisible = true;
188 columns = CreateColumnsInstance();
189 columns.CollectionChanged += OnColumnCollectionChanged;
190 dataMember = String.Empty;
191 defaultCellStyle = new DataGridViewCellStyle();
192 defaultCellStyle.BackColor = SystemColors.Window;
193 defaultCellStyle.ForeColor = SystemColors.ControlText;
194 defaultCellStyle.SelectionBackColor = SystemColors.Highlight;
195 defaultCellStyle.SelectionForeColor = SystemColors.HighlightText;
196 defaultCellStyle.Font = this.Font;
197 defaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleLeft;
198 defaultCellStyle.WrapMode = DataGridViewTriState.False;
199 editMode = DataGridViewEditMode.EditOnKeystrokeOrF2;
200 firstDisplayedScrollingColumnHiddenWidth = 0;
201 isCurrentCellDirty = false;
204 rowHeadersBorderStyle = DataGridViewHeaderBorderStyle.Single;
205 rowHeadersDefaultCellStyle = (DataGridViewCellStyle) columnHeadersDefaultCellStyle.Clone ();
206 rowHeadersVisible = true;
207 rowHeadersWidth = 41;
208 rowHeadersWidthSizeMode = DataGridViewRowHeadersWidthSizeMode.EnableResizing;
209 rows = CreateRowsInstance();
210 rowsDefaultCellStyle = new DataGridViewCellStyle();
211 selectionMode = DataGridViewSelectionMode.RowHeaderSelect;
212 showCellErrors = true;
213 showEditingIcon = true;
214 userSetCursor = Cursor.Current;
217 horizontalScrollBar = new HScrollBar();
218 horizontalScrollBar.Scroll += OnHScrollBarScroll;
219 horizontalScrollBar.Visible = false;
221 verticalScrollBar = new VScrollBar();
222 verticalScrollBar.Scroll += OnVScrollBarScroll;
223 verticalScrollBar.Visible = false;
225 Controls.AddRange (new Control[] {horizontalScrollBar, verticalScrollBar});
228 void ISupportInitialize.BeginInit ()
232 void ISupportInitialize.EndInit ()
239 [EditorBrowsable (EditorBrowsableState.Advanced)]
240 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
241 public virtual DataGridViewAdvancedBorderStyle AdjustedTopLeftHeaderBorderStyle {
242 get { return adjustedTopLeftHeaderBorderStyle; }
246 [EditorBrowsable (EditorBrowsableState.Advanced)]
247 public DataGridViewAdvancedBorderStyle AdvancedCellBorderStyle {
248 get { return advancedCellBorderStyle; }
252 [EditorBrowsable (EditorBrowsableState.Advanced)]
253 public DataGridViewAdvancedBorderStyle AdvancedColumnHeadersBorderStyle {
254 get { return advancedColumnHeadersBorderStyle; }
258 [EditorBrowsable (EditorBrowsableState.Advanced)]
259 public DataGridViewAdvancedBorderStyle AdvancedRowHeadersBorderStyle {
260 get { return advancedRowHeadersBorderStyle; }
263 [DefaultValue (true)]
264 public bool AllowUserToAddRows {
265 get { return allowUserToAddRows; }
267 if (allowUserToAddRows != value) {
268 allowUserToAddRows = value;
269 OnAllowUserToAddRowsChanged(EventArgs.Empty);
270 PrepareEditingRow (false, false);
276 [DefaultValue (true)]
277 public bool AllowUserToDeleteRows {
278 get { return allowUserToDeleteRows; }
280 if (allowUserToDeleteRows != value) {
281 allowUserToDeleteRows = value;
282 OnAllowUserToDeleteRowsChanged(EventArgs.Empty);
287 [DefaultValue (false)]
288 public bool AllowUserToOrderColumns {
289 get { return allowUserToOrderColumns; }
291 if (allowUserToOrderColumns != value) {
292 allowUserToOrderColumns = value;
293 OnAllowUserToOrderColumnsChanged(EventArgs.Empty);
298 [DefaultValue (true)]
299 public bool AllowUserToResizeColumns {
300 get { return allowUserToResizeColumns; }
302 if (allowUserToResizeColumns != value) {
303 allowUserToResizeColumns = value;
304 OnAllowUserToResizeColumnsChanged(EventArgs.Empty);
309 [DefaultValue (true)]
310 public bool AllowUserToResizeRows {
311 get { return allowUserToResizeRows; }
313 if (allowUserToResizeRows != value) {
314 allowUserToResizeRows = value;
315 OnAllowUserToResizeRowsChanged(EventArgs.Empty);
320 public DataGridViewCellStyle AlternatingRowsDefaultCellStyle {
321 get { return alternatingRowsDefaultCellStyle; }
323 if (alternatingRowsDefaultCellStyle != value) {
324 alternatingRowsDefaultCellStyle = value;
325 OnAlternatingRowsDefaultCellStyleChanged(EventArgs.Empty);
332 [EditorBrowsable (EditorBrowsableState.Advanced)]
333 [DefaultValue (true)]
334 public bool AutoGenerateColumns {
335 get { return autoGenerateColumns; }
337 if (autoGenerateColumns != value) {
338 autoGenerateColumns = value;
339 OnAutoGenerateColumnsChanged(EventArgs.Empty);
344 public override bool AutoSize {
345 get { return autoSize; }
347 if (autoSize != value) {
349 //OnAutoSizeChanged(EventArgs.Empty);
354 [DefaultValue (DataGridViewAutoSizeColumnsMode.None)]
355 public DataGridViewAutoSizeColumnsMode AutoSizeColumnsMode {
356 get { return autoSizeColumnsMode; }
358 if (!Enum.IsDefined(typeof(DataGridViewAutoSizeColumnsMode), value)) {
359 throw new InvalidEnumArgumentException("Value is not valid DataGridViewAutoSizeColumnsMode.");
361 if (value == DataGridViewAutoSizeColumnsMode.ColumnHeader && columnHeadersVisible == false) {
362 foreach (DataGridViewColumn col in columns) {
363 if (col.AutoSizeMode == DataGridViewAutoSizeColumnMode.NotSet) {
364 throw new InvalidOperationException("Cant set this property to ColumnHeader in this DataGridView.");
368 if (value == DataGridViewAutoSizeColumnsMode.Fill) {
369 foreach (DataGridViewColumn col in columns) {
370 if (col.AutoSizeMode == DataGridViewAutoSizeColumnMode.NotSet) {
372 throw new InvalidOperationException("Cant set this property to Fill in this DataGridView.");
378 autoSizeColumnsMode = value;
379 AutoResizeColumns (value);
384 [DefaultValue (DataGridViewAutoSizeRowsMode.None)]
385 public DataGridViewAutoSizeRowsMode AutoSizeRowsMode {
386 get { return autoSizeRowsMode; }
388 if (autoSizeRowsMode != value) {
389 if (!Enum.IsDefined(typeof(DataGridViewAutoSizeRowsMode), value)) {
390 throw new InvalidEnumArgumentException("Value is not valid DataGridViewRowsMode.");
392 if ((value == DataGridViewAutoSizeRowsMode.AllHeaders || value == DataGridViewAutoSizeRowsMode.DisplayedHeaders) && rowHeadersVisible == false) {
393 throw new InvalidOperationException("Cant set this property to AllHeaders or DisplayedHeaders in this DataGridView.");
395 autoSizeRowsMode = value;
397 if (value == DataGridViewAutoSizeRowsMode.None)
398 foreach (DataGridViewRow row in Rows)
399 row.ResetToExplicitHeight ();
401 AutoResizeRows (value);
403 OnAutoSizeRowsModeChanged(new DataGridViewAutoSizeModeEventArgs(false));
405 ////////////////////////////////////////////////////////////////
411 [EditorBrowsable (EditorBrowsableState.Never)]
412 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
413 public override Color BackColor {
414 get { return backColor; }
416 if (backColor != value) {
418 OnBackColorChanged(EventArgs.Empty);
423 public Color BackgroundColor {
424 get { return backgroundColor; }
426 if (backgroundColor != value) {
427 if (value == Color.Empty) {
428 throw new ArgumentException("Cant set an Empty color.");
430 backgroundColor = value;
431 OnBackgroundColorChanged(EventArgs.Empty);
437 [EditorBrowsable (EditorBrowsableState.Never)]
438 public override Image BackgroundImage {
439 get { return backgroundImage; }
441 if (backgroundImage != value) {
442 backgroundImage = value;
443 OnBackgroundImageChanged(EventArgs.Empty);
449 [EditorBrowsable (EditorBrowsableState.Never)]
450 public override ImageLayout BackgroundImageLayout {
451 get { return base.BackgroundImageLayout; }
452 set { base.BackgroundImageLayout = value; }
455 [DefaultValue (BorderStyle.FixedSingle)]
456 public BorderStyle BorderStyle {
457 get { return borderStyle; }
459 if (borderStyle != value) {
460 if (!Enum.IsDefined(typeof(BorderStyle), value)) {
461 throw new InvalidEnumArgumentException("Invalid border style.");
464 OnBorderStyleChanged(EventArgs.Empty);
469 internal int BorderWidth {
471 switch (BorderStyle) {
472 case BorderStyle.Fixed3D:
474 case BorderStyle.FixedSingle:
476 case BorderStyle.None:
484 [DefaultValue (DataGridViewCellBorderStyle.Single)]
485 public DataGridViewCellBorderStyle CellBorderStyle {
486 get { return cellBorderStyle; }
488 if (cellBorderStyle != value) {
489 if (value == DataGridViewCellBorderStyle.Custom)
490 throw new ArgumentException ("CellBorderStyle cannot be set to Custom.");
492 cellBorderStyle = value;
494 DataGridViewAdvancedBorderStyle border = new DataGridViewAdvancedBorderStyle ();
496 switch (cellBorderStyle) {
497 case DataGridViewCellBorderStyle.Single:
498 border.All = DataGridViewAdvancedCellBorderStyle.Single;
500 case DataGridViewCellBorderStyle.Raised:
501 case DataGridViewCellBorderStyle.RaisedVertical:
502 border.Bottom = DataGridViewAdvancedCellBorderStyle.None;
503 border.Top = DataGridViewAdvancedCellBorderStyle.None;
504 border.Left = DataGridViewAdvancedCellBorderStyle.Outset;
505 border.Right = DataGridViewAdvancedCellBorderStyle.Outset;
507 case DataGridViewCellBorderStyle.Sunken:
508 border.All = DataGridViewAdvancedCellBorderStyle.Inset;
510 case DataGridViewCellBorderStyle.None:
511 border.All = DataGridViewAdvancedCellBorderStyle.None;
513 case DataGridViewCellBorderStyle.SingleVertical:
514 border.Bottom = DataGridViewAdvancedCellBorderStyle.None;
515 border.Top = DataGridViewAdvancedCellBorderStyle.None;
516 border.Left = DataGridViewAdvancedCellBorderStyle.None;
517 border.Right = DataGridViewAdvancedCellBorderStyle.Single;
519 case DataGridViewCellBorderStyle.SunkenVertical:
520 border.Bottom = DataGridViewAdvancedCellBorderStyle.None;
521 border.Top = DataGridViewAdvancedCellBorderStyle.None;
522 border.Left = DataGridViewAdvancedCellBorderStyle.Inset;
523 border.Right = DataGridViewAdvancedCellBorderStyle.Inset;
525 case DataGridViewCellBorderStyle.SingleHorizontal:
526 case DataGridViewCellBorderStyle.SunkenHorizontal:
527 border.Bottom = DataGridViewAdvancedCellBorderStyle.Inset;
528 border.Top = DataGridViewAdvancedCellBorderStyle.Inset;
529 border.Left = DataGridViewAdvancedCellBorderStyle.None;
530 border.Right = DataGridViewAdvancedCellBorderStyle.None;
532 case DataGridViewCellBorderStyle.RaisedHorizontal:
533 border.Bottom = DataGridViewAdvancedCellBorderStyle.Outset;
534 border.Top = DataGridViewAdvancedCellBorderStyle.Outset;
535 border.Left = DataGridViewAdvancedCellBorderStyle.None;
536 border.Right = DataGridViewAdvancedCellBorderStyle.None;
540 advancedCellBorderStyle = border;
542 OnCellBorderStyleChanged (EventArgs.Empty);
548 [DefaultValue (DataGridViewClipboardCopyMode.EnableWithAutoHeaderText)]
549 public DataGridViewClipboardCopyMode ClipboardCopyMode {
550 get { return clipboardCopyMode; }
551 set { clipboardCopyMode = value; }
555 [EditorBrowsable (EditorBrowsableState.Advanced)]
556 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
558 public int ColumnCount {
559 get { return columns.Count; }
562 throw new ArgumentOutOfRangeException("ColumnCount",
563 "ColumnCount must be >= 0.");
565 if (dataSource != null) {
566 throw new InvalidOperationException("Cant change column count if DataSource is set.");
568 if (value < columns.Count) {
569 for (int i = value; i < columns.Count; i++) {
573 else if (value > columns.Count) {
574 for (int i = 0; i < value; i++) {
575 DataGridViewTextBoxColumn col = new DataGridViewTextBoxColumn ();
583 [DefaultValue (DataGridViewHeaderBorderStyle.Raised)]
584 public DataGridViewHeaderBorderStyle ColumnHeadersBorderStyle {
585 get { return columnHeadersBorderStyle; }
587 if (columnHeadersBorderStyle != value) {
588 columnHeadersBorderStyle = value;
589 OnColumnHeadersBorderStyleChanged(EventArgs.Empty);
594 [AmbientValue (null)]
595 public DataGridViewCellStyle ColumnHeadersDefaultCellStyle {
596 get { return columnHeadersDefaultCellStyle; }
598 if (columnHeadersDefaultCellStyle != value) {
599 columnHeadersDefaultCellStyle = value;
600 OnColumnHeadersDefaultCellStyleChanged(EventArgs.Empty);
606 public int ColumnHeadersHeight {
607 get { return columnHeadersHeight; }
609 if (columnHeadersHeight != value) {
611 throw new ArgumentOutOfRangeException("ColumnHeadersHeight",
612 "Column headers height cant be less than 4.");
614 if (value > 32768 ) {
615 throw new ArgumentOutOfRangeException("ColumnHeadersHeight",
616 "Column headers height cannot be more than 32768.");
618 columnHeadersHeight = value;
619 OnColumnHeadersHeightChanged(EventArgs.Empty);
621 if (columnHeadersVisible)
627 [RefreshProperties (RefreshProperties.All)]
628 [DefaultValue (DataGridViewColumnHeadersHeightSizeMode.EnableResizing)]
629 public DataGridViewColumnHeadersHeightSizeMode ColumnHeadersHeightSizeMode {
630 get { return columnHeadersHeightSizeMode; }
632 if (columnHeadersHeightSizeMode != value) {
633 if (!Enum.IsDefined(typeof(DataGridViewColumnHeadersHeightSizeMode), value)) {
634 throw new InvalidEnumArgumentException("Value is not a valid DataGridViewColumnHeadersHeightSizeMode.");
636 columnHeadersHeightSizeMode = value;
637 OnColumnHeadersHeightSizeModeChanged(new DataGridViewAutoSizeModeEventArgs(false));
642 [DefaultValue (true)]
643 public bool ColumnHeadersVisible {
644 get { return columnHeadersVisible; }
646 if (columnHeadersVisible != value) {
647 columnHeadersVisible = value;
653 [MergableProperty (false)]
654 [Editor ("System.Windows.Forms.Design.DataGridViewColumnCollectionEditor, " + Consts.AssemblySystem_Design, typeof (System.Drawing.Design.UITypeEditor))]
655 [DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]
656 public DataGridViewColumnCollection Columns {
657 get { return columns; }
661 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
662 public DataGridViewCell CurrentCell {
663 get { return currentCell; }
665 /////////////////////////////////////////////////////
666 /// *** InvalidOperationException ***
667 /// Changes to the specified cell cannot be committed
668 /// to the data cache, or the new cell is in a hidden
670 /////////////////////////////////////////////////////
671 if (value.DataGridView != this)
672 throw new ArgumentException("The cell is not in this DataGridView.");
675 MoveCurrentCell (value.OwningColumn.Index, value.OwningRow.Index, true, false, false, true);
677 MoveCurrentCell (-1, -1, true, false, false, true);
682 public Point CurrentCellAddress {
683 get { return currentCellAddress; }
687 public DataGridViewRow CurrentRow {
689 if (currentCell != null)
690 return currentCell.OwningRow;
696 [Editor ("System.Windows.Forms.Design.DataMemberListEditor, " + Consts.AssemblySystem_Design, typeof (System.Drawing.Design.UITypeEditor))]
697 public string DataMember {
698 get { return dataMember; }
700 if (dataMember != value) {
704 OnDataMemberChanged(EventArgs.Empty);
711 [RefreshProperties (RefreshProperties.Repaint)]
712 [DefaultValue (null)]
713 [AttributeProvider (typeof (IListSource))]
714 public object DataSource {
715 get { return dataSource; }
717 /* The System.Windows.Forms.DataGridView class supports the standard Windows Forms data-binding model. This means the data source can be of any type that implements:
718 - the System.Collections.IList interface, including one-dimensional arrays.
719 - the System.ComponentModel.IListSource interface, such as the System.Data.DataTable and System.Data.DataSet classes.
720 - the System.ComponentModel.IBindingList interface, such as the System.ComponentModel.Collections.BindingList<> class.
721 - the System.ComponentModel.IBindingListView interface, such as the System.Windows.Forms.BindingSource class.
723 if (!(value == null || value is IList || value is IListSource || value is IBindingList || value is IBindingListView))
724 throw new NotSupportedException ("Type cannot be bound.");
729 OnDataSourceChanged (EventArgs.Empty);
735 [AmbientValue (null)]
736 public DataGridViewCellStyle DefaultCellStyle {
737 get { return defaultCellStyle; }
739 if (defaultCellStyle != value) {
740 defaultCellStyle = value;
741 OnDefaultCellStyleChanged(EventArgs.Empty);
746 public override Rectangle DisplayRectangle {
747 get { return base.DisplayRectangle; }
751 [EditorBrowsable (EditorBrowsableState.Advanced)]
752 public Control EditingControl {
754 return editingControl;
759 [EditorBrowsable (EditorBrowsableState.Advanced)]
760 public Panel EditingPanel {
761 get { throw new NotImplementedException(); }
764 [DefaultValue (DataGridViewEditMode.EditOnKeystrokeOrF2)]
765 public DataGridViewEditMode EditMode {
766 get { return editMode; }
768 if (editMode != value) {
770 OnEditModeChanged(EventArgs.Empty);
775 [DefaultValue (true)]
776 public bool EnableHeadersVisualStyles {
777 get { return enableHeadersVisualStyles; }
778 set { enableHeadersVisualStyles = value; }
781 internal DataGridViewHeaderCell EnteredHeaderCell {
782 get { return entered_header_cell; }
784 if (entered_header_cell == value)
786 if (ThemeEngine.Current.DataGridViewHeaderCellHasHotStyle (this)) {
787 Region area_to_invalidate = new Region ();
788 area_to_invalidate.MakeEmpty ();
789 if (entered_header_cell != null)
790 area_to_invalidate.Union (GetHeaderCellBounds (entered_header_cell));
791 entered_header_cell = value;
792 if (entered_header_cell != null)
793 area_to_invalidate.Union (GetHeaderCellBounds (entered_header_cell));
794 Invalidate (area_to_invalidate);
795 area_to_invalidate.Dispose ();
797 entered_header_cell = value;
802 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
803 public DataGridViewCell FirstDisplayedCell {
804 get { return firstDisplayedCell; }
806 if (value.DataGridView != this) {
807 throw new ArgumentException("The cell is not in this DataGridView.");
809 firstDisplayedCell = value;
814 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
815 [EditorBrowsable (EditorBrowsableState.Advanced)]
816 public int FirstDisplayedScrollingColumnHiddenWidth {
817 get { return firstDisplayedScrollingColumnHiddenWidth; }
821 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
822 public int FirstDisplayedScrollingColumnIndex {
823 get { return firstDisplayedScrollingColumnIndex; }
824 set { firstDisplayedScrollingColumnIndex = value; }
828 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
829 public int FirstDisplayedScrollingRowIndex {
830 get { return firstDisplayedScrollingRowIndex; }
831 set { firstDisplayedScrollingRowIndex = value; }
835 [EditorBrowsable (EditorBrowsableState.Advanced)]
836 public override Font Font {
837 get { return base.Font; }
838 set { base.Font = value; }
842 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
843 [EditorBrowsable (EditorBrowsableState.Advanced)]
844 public override Color ForeColor {
845 get { return base.ForeColor; }
846 set { base.ForeColor = value; }
849 public Color GridColor {
850 get { return gridColor; }
852 if (gridColor != value) {
853 if (value == Color.Empty) {
854 throw new ArgumentException("Cant set an Empty color.");
857 OnGridColorChanged(EventArgs.Empty);
863 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
864 public int HorizontalScrollingOffset {
865 get { return horizontalScrollingOffset; }
866 set { horizontalScrollingOffset = value; }
870 public bool IsCurrentCellDirty {
871 get { return isCurrentCellDirty; }
875 public bool IsCurrentCellInEditMode {
877 if (currentCell == null) {
880 return currentCell.IsInEditMode;
885 public bool IsCurrentRowDirty {
888 return IsCurrentCellDirty;
891 throw new NotImplementedException();
896 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
897 public DataGridViewCell this [int columnIndex, int rowIndex] {
898 get { return rows[rowIndex].Cells[columnIndex]; }
899 set { rows[rowIndex].Cells[columnIndex] = value; }
903 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
904 public DataGridViewCell this [string columnName, int rowIndex] {
906 int columnIndex = -1;
907 foreach (DataGridViewColumn col in columns) {
908 if (col.Name == columnName) {
909 columnIndex = col.Index;
913 return this[columnIndex, rowIndex];
916 int columnIndex = -1;
917 foreach (DataGridViewColumn col in columns) {
918 if (col.Name == columnName) {
919 columnIndex = col.Index;
923 this[columnIndex, rowIndex] = value;
927 [DefaultValue (true)]
928 public bool MultiSelect {
929 get { return multiSelect; }
931 if (multiSelect != value) {
933 OnMultiSelectChanged(EventArgs.Empty);
939 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
940 public int NewRowIndex {
942 if (!allowUserToAddRows || ColumnCount == 0) {
945 return rows.Count - 1;
950 [EditorBrowsable (EditorBrowsableState.Never)]
951 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
952 public new Padding Padding {
953 get { return Padding.Empty; }
957 internal DataGridViewHeaderCell PressedHeaderCell {
958 get { return pressed_header_cell; }
962 [DefaultValue (false)]
963 public bool ReadOnly {
964 get { return readOnly; }
966 if (readOnly != value) {
968 OnReadOnlyChanged(EventArgs.Empty);
974 [EditorBrowsable (EditorBrowsableState.Advanced)]
975 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
977 public int RowCount {
978 get { return rows.Count; }
981 throw new ArgumentException("RowCount must be >= 0.");
983 if (value < 1 && allowUserToAddRows) {
984 throw new ArgumentException("RowCount must be >= 1 if AllowUserToAddRows is true.");
986 if (dataSource != null) {
987 throw new InvalidOperationException("Cant change row count if DataSource is set.");
989 if (value < rows.Count) {
990 for (int i = value; i < rows.Count; i++) {
994 else if (value > rows.Count) {
995 // If we need to add rows and don't have any columns,
996 // we create one column
997 if (ColumnCount == 0)
1000 for (int i = rows.Count; i < value; i++) {
1001 DataGridViewRow row = (DataGridViewRow) RowTemplateFull;
1002 rows.AddInternal (row, false);
1004 foreach (DataGridViewColumn col in columns)
1005 row.Cells.Add (col.CellTemplate.Clone () as DataGridViewCell);
1012 [DefaultValue (DataGridViewHeaderBorderStyle.Raised)]
1013 public DataGridViewHeaderBorderStyle RowHeadersBorderStyle {
1014 get { return rowHeadersBorderStyle; }
1016 if (rowHeadersBorderStyle != value) {
1017 rowHeadersBorderStyle = value;
1018 OnRowHeadersBorderStyleChanged(EventArgs.Empty);
1023 [AmbientValue (null)]
1024 public DataGridViewCellStyle RowHeadersDefaultCellStyle {
1025 get { return rowHeadersDefaultCellStyle; }
1027 if (rowHeadersDefaultCellStyle != value) {
1028 rowHeadersDefaultCellStyle = value;
1029 OnRowHeadersDefaultCellStyleChanged(EventArgs.Empty);
1034 [DefaultValue (true)]
1035 public bool RowHeadersVisible {
1036 get { return rowHeadersVisible; }
1038 if (rowHeadersVisible != value) {
1039 rowHeadersVisible = value;
1045 [Localizable (true)]
1046 public int RowHeadersWidth {
1047 get { return rowHeadersWidth; }
1049 if (rowHeadersWidth != value) {
1051 throw new ArgumentOutOfRangeException("RowHeadersWidth",
1052 "Row headers width cant be less than 4.");
1054 if (value > 32768 ) {
1055 throw new ArgumentOutOfRangeException("RowHeadersWidth",
1056 "Row headers width cannot be more than 32768.");
1058 rowHeadersWidth = value;
1059 OnRowHeadersWidthChanged(EventArgs.Empty);
1061 if (rowHeadersVisible)
1067 [RefreshProperties (RefreshProperties.All)]
1068 [DefaultValue (DataGridViewRowHeadersWidthSizeMode.EnableResizing)]
1069 public DataGridViewRowHeadersWidthSizeMode RowHeadersWidthSizeMode {
1070 get { return rowHeadersWidthSizeMode; }
1072 if (rowHeadersWidthSizeMode != value) {
1073 if (!Enum.IsDefined(typeof(DataGridViewRowHeadersWidthSizeMode), value)) {
1074 throw new InvalidEnumArgumentException("Value is not valid DataGridViewRowHeadersWidthSizeMode.");
1076 rowHeadersWidthSizeMode = value;
1077 OnRowHeadersWidthSizeModeChanged(new DataGridViewAutoSizeModeEventArgs(false));
1083 public DataGridViewRowCollection Rows {
1084 get { return rows; }
1087 public DataGridViewCellStyle RowsDefaultCellStyle {
1088 get { return rowsDefaultCellStyle; }
1090 if (rowsDefaultCellStyle != value) {
1091 rowsDefaultCellStyle = value;
1092 OnRowsDefaultCellStyleChanged(EventArgs.Empty);
1097 // RowTemplate is just the row, it does not contain Cells
1099 [DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]
1100 public DataGridViewRow RowTemplate {
1102 if (rowTemplate == null)
1103 rowTemplate = new DataGridViewRow ();
1108 rowTemplate = value;
1109 rowTemplate.SetDataGridView(this);
1113 // Take the RowTemplate, clone it, and add Cells
1114 // Note this is not stored, so you don't need to Clone it
1115 internal DataGridViewRow RowTemplateFull {
1117 DataGridViewRow row = (DataGridViewRow) RowTemplate.Clone ();
1119 for (int i = row.Cells.Count; i < Columns.Count; i++) {
1120 DataGridViewCell template = columns [i].CellTemplate;
1122 if (template == null)
1123 throw new InvalidOperationException ("At least one of the DataGridView control's columns has no cell template.");
1125 row.Cells.Add ((DataGridViewCell) template.Clone ());
1132 internal override bool ScaleChildrenInternal {
1133 get { return false; }
1136 [DefaultValue (ScrollBars.Both)]
1137 [Localizable (true)]
1138 public ScrollBars ScrollBars {
1139 get { return scrollBars; }
1141 if (!Enum.IsDefined(typeof(ScrollBars), value)) {
1142 throw new InvalidEnumArgumentException("Invalid ScrollBars value.");
1144 ////////////////////////////////////////////////////////////
1145 /// *** InvalidOperationException ***
1146 /// The System.Windows.Forms.DataGridView is unable to
1147 /// scroll due to a cell change that cannot be committed
1149 ///////////////////////////////////////////////////////////
1155 public DataGridViewSelectedCellCollection SelectedCells {
1157 DataGridViewSelectedCellCollection selectedCells = new DataGridViewSelectedCellCollection();
1158 foreach (DataGridViewRow row in rows) {
1159 foreach (DataGridViewCell cell in row.Cells) {
1160 if (cell.Selected) {
1161 selectedCells.InternalAdd(cell);
1165 return selectedCells;
1170 public DataGridViewSelectedColumnCollection SelectedColumns {
1173 DataGridViewSelectedColumnCollection result = new DataGridViewSelectedColumnCollection ();
1175 if (selectionMode != DataGridViewSelectionMode.FullColumnSelect && selectionMode != DataGridViewSelectionMode.ColumnHeaderSelect)
1178 result.InternalAddRange (selected_columns);
1185 public DataGridViewSelectedRowCollection SelectedRows {
1187 DataGridViewSelectedRowCollection result = new DataGridViewSelectedRowCollection (this);
1189 if (selectionMode != DataGridViewSelectionMode.FullRowSelect && selectionMode != DataGridViewSelectionMode.RowHeaderSelect)
1192 result.InternalAddRange (selected_rows);
1199 [DefaultValue (DataGridViewSelectionMode.RowHeaderSelect)]
1200 public DataGridViewSelectionMode SelectionMode {
1201 get { return selectionMode; }
1203 if (!Enum.IsDefined (typeof(DataGridViewSelectionMode), value))
1204 throw new InvalidEnumArgumentException ("Value is not valid DataGridViewSelectionMode.");
1206 if (value == DataGridViewSelectionMode.ColumnHeaderSelect || value == DataGridViewSelectionMode.FullColumnSelect)
1207 foreach (DataGridViewColumn col in Columns)
1208 if (col.SortMode == DataGridViewColumnSortMode.Automatic)
1209 throw new InvalidOperationException (string.Format ("Cannot set SelectionMode to {0} because there are Automatic sort columns.", value));
1211 selectionMode = value;
1215 [DefaultValue (true)]
1216 public bool ShowCellErrors {
1217 get { return showCellErrors; }
1218 set { showCellErrors = value; }
1221 [DefaultValue (true)]
1222 public bool ShowCellToolTips {
1223 get { return showCellToolTips; }
1224 set { showCellToolTips = value; }
1227 [DefaultValue (true)]
1228 public bool ShowEditingIcon {
1229 get { return showEditingIcon; }
1230 set { showEditingIcon = value; }
1233 [DefaultValue (true)]
1234 public bool ShowRowErrors {
1235 get { return showRowErrors; }
1236 set { showRowErrors = value; }
1240 public DataGridViewColumn SortedColumn {
1241 get { return sortedColumn; }
1245 public SortOrder SortOrder {
1246 get { return sortOrder; }
1249 [DefaultValue (false)]
1250 [EditorBrowsable (EditorBrowsableState.Advanced)]
1251 public bool StandardTab {
1252 get { return standardTab; }
1253 set { standardTab = value; }
1258 [EditorBrowsable (EditorBrowsableState.Never)]
1259 public override string Text {
1260 get { return base.Text; }
1261 set { base.Text = value; }
1265 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
1266 public DataGridViewHeaderCell TopLeftHeaderCell {
1268 if (topLeftHeaderCell == null) {
1269 topLeftHeaderCell = new DataGridViewTopLeftHeaderCell ();
1270 topLeftHeaderCell.SetDataGridView (this);
1272 return topLeftHeaderCell;
1275 topLeftHeaderCell = value;
1276 topLeftHeaderCell.SetDataGridView (this);
1281 [EditorBrowsable (EditorBrowsableState.Advanced)]
1282 public Cursor UserSetCursor {
1283 get { return userSetCursor; }
1287 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
1288 public int VerticalScrollingOffset {
1289 get { return verticalScrollingOffset; }
1292 [MonoTODO ("VirtualMode is not supported.")]
1293 [EditorBrowsable (EditorBrowsableState.Advanced)]
1294 [DefaultValue (false)]
1295 public bool VirtualMode {
1296 get { return virtualMode; }
1297 set { virtualMode = value; }
1300 internal Control EditingControlInternal {
1302 return editingControl;
1305 if (value == editingControl)
1308 if (editingControl != null) {
1309 // Can't use Controls.Remove (editingControls), because that method
1310 // is overriden to not remove the editing control.
1311 DataGridView.DataGridViewControlCollection ctrls = Controls as DataGridView.DataGridViewControlCollection;
1312 if (ctrls != null) {
1313 ctrls.RemoveInternal (editingControl);
1315 Controls.Remove (editingControl);
1320 if (value != null) {
1321 value.Visible = false;
1322 Controls.Add (value);
1325 editingControl = value;
1329 static object AllowUserToAddRowsChangedEvent = new object ();
1330 static object AllowUserToDeleteRowsChangedEvent = new object ();
1331 static object AllowUserToOrderColumnsChangedEvent = new object ();
1332 static object AllowUserToResizeColumnsChangedEvent = new object ();
1333 static object AllowUserToResizeRowsChangedEvent = new object ();
1334 static object AlternatingRowsDefaultCellStyleChangedEvent = new object ();
1335 static object AutoGenerateColumnsChangedEvent = new object ();
1336 static object AutoSizeColumnModeChangedEvent = new object ();
1337 static object AutoSizeColumnsModeChangedEvent = new object ();
1338 static object AutoSizeRowsModeChangedEvent = new object ();
1339 static object BackgroundColorChangedEvent = new object ();
1340 static object BorderStyleChangedEvent = new object ();
1341 static object CancelRowEditEvent = new object ();
1342 static object CellBeginEditEvent = new object ();
1343 static object CellBorderStyleChangedEvent = new object ();
1344 static object CellClickEvent = new object ();
1345 static object CellContentClickEvent = new object ();
1346 static object CellContentDoubleClickEvent = new object ();
1347 static object CellContextMenuStripChangedEvent = new object ();
1348 static object CellContextMenuStripNeededEvent = new object ();
1349 static object CellDoubleClickEvent = new object ();
1350 static object CellEndEditEvent = new object ();
1351 static object CellEnterEvent = new object ();
1352 static object CellErrorTextChangedEvent = new object ();
1353 static object CellErrorTextNeededEvent = new object ();
1354 static object CellFormattingEvent = new object ();
1355 static object CellLeaveEvent = new object ();
1356 static object CellMouseClickEvent = new object ();
1357 static object CellMouseDoubleClickEvent = new object ();
1358 static object CellMouseDownEvent = new object ();
1359 static object CellMouseEnterEvent = new object ();
1360 static object CellMouseLeaveEvent = new object ();
1361 static object CellMouseMoveEvent = new object ();
1362 static object CellMouseUpEvent = new object ();
1363 static object CellPaintingEvent = new object ();
1364 static object CellParsingEvent = new object ();
1365 static object CellStateChangedEvent = new object ();
1366 static object CellStyleChangedEvent = new object ();
1367 static object CellStyleContentChangedEvent = new object ();
1368 static object CellToolTipTextChangedEvent = new object ();
1369 static object CellToolTipTextNeededEvent = new object ();
1370 static object CellValidatedEvent = new object ();
1371 static object CellValidatingEvent = new object ();
1372 static object CellValueChangedEvent = new object ();
1373 static object CellValueNeededEvent = new object ();
1374 static object CellValuePushedEvent = new object ();
1375 static object ColumnAddedEvent = new object ();
1376 static object ColumnContextMenuStripChangedEvent = new object ();
1377 static object ColumnDataPropertyNameChangedEvent = new object ();
1378 static object ColumnDefaultCellStyleChangedEvent = new object ();
1379 static object ColumnDisplayIndexChangedEvent = new object ();
1380 static object ColumnDividerDoubleClickEvent = new object ();
1381 static object ColumnDividerWidthChangedEvent = new object ();
1382 static object ColumnHeaderCellChangedEvent = new object ();
1383 static object ColumnHeaderMouseClickEvent = new object ();
1384 static object ColumnHeaderMouseDoubleClickEvent = new object ();
1385 static object ColumnHeadersBorderStyleChangedEvent = new object ();
1386 static object ColumnHeadersDefaultCellStyleChangedEvent = new object ();
1387 static object ColumnHeadersHeightChangedEvent = new object ();
1388 static object ColumnHeadersHeightSizeModeChangedEvent = new object ();
1389 static object ColumnMinimumWidthChangedEvent = new object ();
1390 static object ColumnNameChangedEvent = new object ();
1391 static object ColumnRemovedEvent = new object ();
1392 static object ColumnSortModeChangedEvent = new object ();
1393 static object ColumnStateChangedEvent = new object ();
1394 static object ColumnToolTipTextChangedEvent = new object ();
1395 static object ColumnWidthChangedEvent = new object ();
1396 static object CurrentCellChangedEvent = new object ();
1397 static object CurrentCellDirtyStateChangedEvent = new object ();
1398 static object DataBindingCompleteEvent = new object ();
1399 static object DataErrorEvent = new object ();
1400 static object DataMemberChangedEvent = new object ();
1401 static object DataSourceChangedEvent = new object ();
1402 static object DefaultCellStyleChangedEvent = new object ();
1403 static object DefaultValuesNeededEvent = new object ();
1404 static object EditingControlShowingEvent = new object ();
1405 static object EditModeChangedEvent = new object ();
1406 static object GridColorChangedEvent = new object ();
1407 static object MultiSelectChangedEvent = new object ();
1408 static object NewRowNeededEvent = new object ();
1409 static object ReadOnlyChangedEvent = new object ();
1410 static object RowContextMenuStripChangedEvent = new object ();
1411 static object RowContextMenuStripNeededEvent = new object ();
1412 static object RowDefaultCellStyleChangedEvent = new object ();
1413 static object RowDirtyStateNeededEvent = new object ();
1414 static object RowDividerDoubleClickEvent = new object ();
1415 static object RowDividerHeightChangedEvent = new object ();
1416 static object RowEnterEvent = new object ();
1417 static object RowErrorTextChangedEvent = new object ();
1418 static object RowErrorTextNeededEvent = new object ();
1419 static object RowHeaderCellChangedEvent = new object ();
1420 static object RowHeaderMouseClickEvent = new object ();
1421 static object RowHeaderMouseDoubleClickEvent = new object ();
1422 static object RowHeadersBorderStyleChangedEvent = new object ();
1423 static object RowHeadersDefaultCellStyleChangedEvent = new object ();
1424 static object RowHeadersWidthChangedEvent = new object ();
1425 static object RowHeadersWidthSizeModeChangedEvent = new object ();
1426 static object RowHeightChangedEvent = new object ();
1427 static object RowHeightInfoNeededEvent = new object ();
1428 static object RowHeightInfoPushedEvent = new object ();
1429 static object RowLeaveEvent = new object ();
1430 static object RowMinimumHeightChangedEvent = new object ();
1431 static object RowPostPaintEvent = new object ();
1432 static object RowPrePaintEvent = new object ();
1433 static object RowsAddedEvent = new object ();
1434 static object RowsDefaultCellStyleChangedEvent = new object ();
1435 static object RowsRemovedEvent = new object ();
1436 static object RowStateChangedEvent = new object ();
1437 static object RowUnsharedEvent = new object ();
1438 static object RowValidatedEvent = new object ();
1439 static object RowValidatingEvent = new object ();
1440 static object ScrollEvent = new object ();
1441 static object SelectionChangedEvent = new object ();
1442 static object SortCompareEvent = new object ();
1443 static object SortedEvent = new object ();
1444 static object UserAddedRowEvent = new object ();
1445 static object UserDeletedRowEvent = new object ();
1446 static object UserDeletingRowEvent = new object ();
1451 public event EventHandler AllowUserToAddRowsChanged {
1452 add { Events.AddHandler (AllowUserToAddRowsChangedEvent, value); }
1453 remove { Events.RemoveHandler (AllowUserToAddRowsChangedEvent, value); }
1456 public event EventHandler AllowUserToDeleteRowsChanged {
1457 add { Events.AddHandler (AllowUserToDeleteRowsChangedEvent, value); }
1458 remove { Events.RemoveHandler (AllowUserToDeleteRowsChangedEvent, value); }
1461 public event EventHandler AllowUserToOrderColumnsChanged {
1462 add { Events.AddHandler (AllowUserToOrderColumnsChangedEvent, value); }
1463 remove { Events.RemoveHandler (AllowUserToOrderColumnsChangedEvent, value); }
1466 public event EventHandler AllowUserToResizeColumnsChanged {
1467 add { Events.AddHandler (AllowUserToResizeColumnsChangedEvent, value); }
1468 remove { Events.RemoveHandler (AllowUserToResizeColumnsChangedEvent, value); }
1471 public event EventHandler AllowUserToResizeRowsChanged {
1472 add { Events.AddHandler (AllowUserToResizeRowsChangedEvent, value); }
1473 remove { Events.RemoveHandler (AllowUserToResizeRowsChangedEvent, value); }
1476 public event EventHandler AlternatingRowsDefaultCellStyleChanged {
1477 add { Events.AddHandler (AlternatingRowsDefaultCellStyleChangedEvent, value); }
1478 remove { Events.RemoveHandler (AlternatingRowsDefaultCellStyleChangedEvent, value); }
1482 [EditorBrowsable (EditorBrowsableState.Advanced)]
1483 public event EventHandler AutoGenerateColumnsChanged {
1484 add { Events.AddHandler (AutoGenerateColumnsChangedEvent, value); }
1485 remove { Events.RemoveHandler (AutoGenerateColumnsChangedEvent, value); }
1488 public event DataGridViewAutoSizeColumnModeEventHandler AutoSizeColumnModeChanged {
1489 add { Events.AddHandler (AutoSizeColumnModeChangedEvent, value); }
1490 remove { Events.RemoveHandler (AutoSizeColumnModeChangedEvent, value); }
1493 public event DataGridViewAutoSizeColumnsModeEventHandler AutoSizeColumnsModeChanged {
1494 add { Events.AddHandler (AutoSizeColumnsModeChangedEvent, value); }
1495 remove { Events.RemoveHandler (AutoSizeColumnsModeChangedEvent, value); }
1498 public event DataGridViewAutoSizeModeEventHandler AutoSizeRowsModeChanged {
1499 add { Events.AddHandler (AutoSizeRowsModeChangedEvent, value); }
1500 remove { Events.RemoveHandler (AutoSizeRowsModeChangedEvent, value); }
1504 [EditorBrowsable (EditorBrowsableState.Never)]
1505 public new event EventHandler BackColorChanged {
1506 add { base.BackColorChanged += value; }
1507 remove { base.BackColorChanged -= value; }
1510 public event EventHandler BackgroundColorChanged {
1511 add { Events.AddHandler (BackgroundColorChangedEvent, value); }
1512 remove { Events.RemoveHandler (BackgroundColorChangedEvent, value); }
1516 [EditorBrowsable (EditorBrowsableState.Never)]
1517 public new event EventHandler BackgroundImageChanged {
1518 add { base.BackgroundImageChanged += value; }
1519 remove { base.BackgroundImageChanged -= value; }
1523 [EditorBrowsable (EditorBrowsableState.Never)]
1524 public new event EventHandler BackgroundImageLayoutChanged {
1525 add { base.BackgroundImageLayoutChanged += value; }
1526 remove { base.BackgroundImageLayoutChanged -= value; }
1529 public event EventHandler BorderStyleChanged {
1530 add { Events.AddHandler (BorderStyleChangedEvent, value); }
1531 remove { Events.RemoveHandler (BorderStyleChangedEvent, value); }
1534 public event QuestionEventHandler CancelRowEdit {
1535 add { Events.AddHandler (CancelRowEditEvent, value); }
1536 remove { Events.RemoveHandler (CancelRowEditEvent, value); }
1539 public event DataGridViewCellCancelEventHandler CellBeginEdit {
1540 add { Events.AddHandler (CellBeginEditEvent, value); }
1541 remove { Events.RemoveHandler (CellBeginEditEvent, value); }
1544 public event EventHandler CellBorderStyleChanged {
1545 add { Events.AddHandler (CellBorderStyleChangedEvent, value); }
1546 remove { Events.RemoveHandler (CellBorderStyleChangedEvent, value); }
1549 public event DataGridViewCellEventHandler CellClick {
1550 add { Events.AddHandler (CellClickEvent, value); }
1551 remove { Events.RemoveHandler (CellClickEvent, value); }
1554 public event DataGridViewCellEventHandler CellContentClick {
1555 add { Events.AddHandler (CellContentClickEvent, value); }
1556 remove { Events.RemoveHandler (CellContentClickEvent, value); }
1559 public event DataGridViewCellEventHandler CellContentDoubleClick {
1560 add { Events.AddHandler (CellContentDoubleClickEvent, value); }
1561 remove { Events.RemoveHandler (CellContentDoubleClickEvent, value); }
1564 [EditorBrowsable (EditorBrowsableState.Advanced)]
1565 public event DataGridViewCellEventHandler CellContextMenuStripChanged {
1566 add { Events.AddHandler (CellContextMenuStripChangedEvent, value); }
1567 remove { Events.RemoveHandler (CellContextMenuStripChangedEvent, value); }
1570 [EditorBrowsable (EditorBrowsableState.Advanced)]
1571 public event DataGridViewCellContextMenuStripNeededEventHandler CellContextMenuStripNeeded {
1572 add { Events.AddHandler (CellContextMenuStripNeededEvent, value); }
1573 remove { Events.RemoveHandler (CellContextMenuStripNeededEvent, value); }
1576 public event DataGridViewCellEventHandler CellDoubleClick {
1577 add { Events.AddHandler (CellDoubleClickEvent, value); }
1578 remove { Events.RemoveHandler (CellDoubleClickEvent, value); }
1581 public event DataGridViewCellEventHandler CellEndEdit {
1582 add { Events.AddHandler (CellEndEditEvent, value); }
1583 remove { Events.RemoveHandler (CellEndEditEvent, value); }
1586 public event DataGridViewCellEventHandler CellEnter {
1587 add { Events.AddHandler (CellEnterEvent, value); }
1588 remove { Events.RemoveHandler (CellEnterEvent, value); }
1591 public event DataGridViewCellEventHandler CellErrorTextChanged {
1592 add { Events.AddHandler (CellErrorTextChangedEvent, value); }
1593 remove { Events.RemoveHandler (CellErrorTextChangedEvent, value); }
1596 [EditorBrowsable (EditorBrowsableState.Advanced)]
1597 public event DataGridViewCellErrorTextNeededEventHandler CellErrorTextNeeded {
1598 add { Events.AddHandler (CellErrorTextNeededEvent, value); }
1599 remove { Events.RemoveHandler (CellErrorTextNeededEvent, value); }
1602 public event DataGridViewCellFormattingEventHandler CellFormatting {
1603 add { Events.AddHandler (CellFormattingEvent, value); }
1604 remove { Events.RemoveHandler (CellFormattingEvent, value); }
1607 public event DataGridViewCellEventHandler CellLeave {
1608 add { Events.AddHandler (CellLeaveEvent, value); }
1609 remove { Events.RemoveHandler (CellLeaveEvent, value); }
1612 public event DataGridViewCellMouseEventHandler CellMouseClick {
1613 add { Events.AddHandler (CellMouseClickEvent, value); }
1614 remove { Events.RemoveHandler (CellMouseClickEvent, value); }
1617 public event DataGridViewCellMouseEventHandler CellMouseDoubleClick {
1618 add { Events.AddHandler (CellMouseDoubleClickEvent, value); }
1619 remove { Events.RemoveHandler (CellMouseDoubleClickEvent, value); }
1622 public event DataGridViewCellMouseEventHandler CellMouseDown {
1623 add { Events.AddHandler (CellMouseDownEvent, value); }
1624 remove { Events.RemoveHandler (CellMouseDownEvent, value); }
1627 public event DataGridViewCellEventHandler CellMouseEnter {
1628 add { Events.AddHandler (CellMouseEnterEvent, value); }
1629 remove { Events.RemoveHandler (CellMouseEnterEvent, value); }
1632 public event DataGridViewCellEventHandler CellMouseLeave {
1633 add { Events.AddHandler (CellMouseLeaveEvent, value); }
1634 remove { Events.RemoveHandler (CellMouseLeaveEvent, value); }
1637 public event DataGridViewCellMouseEventHandler CellMouseMove {
1638 add { Events.AddHandler (CellMouseMoveEvent, value); }
1639 remove { Events.RemoveHandler (CellMouseMoveEvent, value); }
1642 public event DataGridViewCellMouseEventHandler CellMouseUp {
1643 add { Events.AddHandler (CellMouseUpEvent, value); }
1644 remove { Events.RemoveHandler (CellMouseUpEvent, value); }
1647 public event DataGridViewCellPaintingEventHandler CellPainting {
1648 add { Events.AddHandler (CellPaintingEvent, value); }
1649 remove { Events.RemoveHandler (CellPaintingEvent, value); }
1652 public event DataGridViewCellParsingEventHandler CellParsing {
1653 add { Events.AddHandler (CellParsingEvent, value); }
1654 remove { Events.RemoveHandler (CellParsingEvent, value); }
1657 public event DataGridViewCellStateChangedEventHandler CellStateChanged {
1658 add { Events.AddHandler (CellStateChangedEvent, value); }
1659 remove { Events.RemoveHandler (CellStateChangedEvent, value); }
1662 public event DataGridViewCellEventHandler CellStyleChanged {
1663 add { Events.AddHandler (CellStyleChangedEvent, value); }
1664 remove { Events.RemoveHandler (CellStyleChangedEvent, value); }
1667 public event DataGridViewCellStyleContentChangedEventHandler CellStyleContentChanged {
1668 add { Events.AddHandler (CellStyleContentChangedEvent, value); }
1669 remove { Events.RemoveHandler (CellStyleContentChangedEvent, value); }
1672 public event DataGridViewCellEventHandler CellToolTipTextChanged {
1673 add { Events.AddHandler (CellToolTipTextChangedEvent, value); }
1674 remove { Events.RemoveHandler (CellToolTipTextChangedEvent, value); }
1677 [EditorBrowsable (EditorBrowsableState.Advanced)]
1678 public event DataGridViewCellToolTipTextNeededEventHandler CellToolTipTextNeeded {
1679 add { Events.AddHandler (CellToolTipTextNeededEvent, value); }
1680 remove { Events.RemoveHandler (CellToolTipTextNeededEvent, value); }
1683 public event DataGridViewCellEventHandler CellValidated {
1684 add { Events.AddHandler (CellValidatedEvent, value); }
1685 remove { Events.RemoveHandler (CellValidatedEvent, value); }
1688 public event DataGridViewCellValidatingEventHandler CellValidating {
1689 add { Events.AddHandler (CellValidatingEvent, value); }
1690 remove { Events.RemoveHandler (CellValidatingEvent, value); }
1693 public event DataGridViewCellEventHandler CellValueChanged {
1694 add { Events.AddHandler (CellValueChangedEvent, value); }
1695 remove { Events.RemoveHandler (CellValueChangedEvent, value); }
1698 [EditorBrowsable (EditorBrowsableState.Advanced)]
1699 public event DataGridViewCellValueEventHandler CellValueNeeded {
1700 add { Events.AddHandler (CellValueNeededEvent, value); }
1701 remove { Events.RemoveHandler (CellValueNeededEvent, value); }
1704 [EditorBrowsable (EditorBrowsableState.Advanced)]
1705 public event DataGridViewCellValueEventHandler CellValuePushed {
1706 add { Events.AddHandler (CellValuePushedEvent, value); }
1707 remove { Events.RemoveHandler (CellValuePushedEvent, value); }
1710 public event DataGridViewColumnEventHandler ColumnAdded {
1711 add { Events.AddHandler (ColumnAddedEvent, value); }
1712 remove { Events.RemoveHandler (ColumnAddedEvent, value); }
1715 public event DataGridViewColumnEventHandler ColumnContextMenuStripChanged {
1716 add { Events.AddHandler (ColumnContextMenuStripChangedEvent, value); }
1717 remove { Events.RemoveHandler (ColumnContextMenuStripChangedEvent, value); }
1720 public event DataGridViewColumnEventHandler ColumnDataPropertyNameChanged {
1721 add { Events.AddHandler (ColumnDataPropertyNameChangedEvent, value); }
1722 remove { Events.RemoveHandler (ColumnDataPropertyNameChangedEvent, value); }
1725 public event DataGridViewColumnEventHandler ColumnDefaultCellStyleChanged {
1726 add { Events.AddHandler (ColumnDefaultCellStyleChangedEvent, value); }
1727 remove { Events.RemoveHandler (ColumnDefaultCellStyleChangedEvent, value); }
1730 public event DataGridViewColumnEventHandler ColumnDisplayIndexChanged {
1731 add { Events.AddHandler (ColumnDisplayIndexChangedEvent, value); }
1732 remove { Events.RemoveHandler (ColumnDisplayIndexChangedEvent, value); }
1735 public event DataGridViewColumnDividerDoubleClickEventHandler ColumnDividerDoubleClick {
1736 add { Events.AddHandler (ColumnDividerDoubleClickEvent, value); }
1737 remove { Events.RemoveHandler (ColumnDividerDoubleClickEvent, value); }
1740 public event DataGridViewColumnEventHandler ColumnDividerWidthChanged {
1741 add { Events.AddHandler (ColumnDividerWidthChangedEvent, value); }
1742 remove { Events.RemoveHandler (ColumnDividerWidthChangedEvent, value); }
1745 public event DataGridViewColumnEventHandler ColumnHeaderCellChanged {
1746 add { Events.AddHandler (ColumnHeaderCellChangedEvent, value); }
1747 remove { Events.RemoveHandler (ColumnHeaderCellChangedEvent, value); }
1750 public event DataGridViewCellMouseEventHandler ColumnHeaderMouseClick {
1751 add { Events.AddHandler (ColumnHeaderMouseClickEvent, value); }
1752 remove { Events.RemoveHandler (ColumnHeaderMouseClickEvent, value); }
1755 public event DataGridViewCellMouseEventHandler ColumnHeaderMouseDoubleClick {
1756 add { Events.AddHandler (ColumnHeaderMouseDoubleClickEvent, value); }
1757 remove { Events.RemoveHandler (ColumnHeaderMouseDoubleClickEvent, value); }
1760 public event EventHandler ColumnHeadersBorderStyleChanged {
1761 add { Events.AddHandler (ColumnHeadersBorderStyleChangedEvent, value); }
1762 remove { Events.RemoveHandler (ColumnHeadersBorderStyleChangedEvent, value); }
1765 public event EventHandler ColumnHeadersDefaultCellStyleChanged {
1766 add { Events.AddHandler (ColumnHeadersDefaultCellStyleChangedEvent, value); }
1767 remove { Events.RemoveHandler (ColumnHeadersDefaultCellStyleChangedEvent, value); }
1770 public event EventHandler ColumnHeadersHeightChanged {
1771 add { Events.AddHandler (ColumnHeadersHeightChangedEvent, value); }
1772 remove { Events.RemoveHandler (ColumnHeadersHeightChangedEvent, value); }
1775 public event DataGridViewAutoSizeModeEventHandler ColumnHeadersHeightSizeModeChanged {
1776 add { Events.AddHandler (ColumnHeadersHeightSizeModeChangedEvent, value); }
1777 remove { Events.RemoveHandler (ColumnHeadersHeightSizeModeChangedEvent, value); }
1780 public event DataGridViewColumnEventHandler ColumnMinimumWidthChanged {
1781 add { Events.AddHandler (ColumnMinimumWidthChangedEvent, value); }
1782 remove { Events.RemoveHandler (ColumnMinimumWidthChangedEvent, value); }
1785 public event DataGridViewColumnEventHandler ColumnNameChanged {
1786 add { Events.AddHandler (ColumnNameChangedEvent, value); }
1787 remove { Events.RemoveHandler (ColumnNameChangedEvent, value); }
1790 public event DataGridViewColumnEventHandler ColumnRemoved {
1791 add { Events.AddHandler (ColumnRemovedEvent, value); }
1792 remove { Events.RemoveHandler (ColumnRemovedEvent, value); }
1795 public event DataGridViewColumnEventHandler ColumnSortModeChanged {
1796 add { Events.AddHandler (ColumnSortModeChangedEvent, value); }
1797 remove { Events.RemoveHandler (ColumnSortModeChangedEvent, value); }
1800 public event DataGridViewColumnStateChangedEventHandler ColumnStateChanged {
1801 add { Events.AddHandler (ColumnStateChangedEvent, value); }
1802 remove { Events.RemoveHandler (ColumnStateChangedEvent, value); }
1805 public event DataGridViewColumnEventHandler ColumnToolTipTextChanged {
1806 add { Events.AddHandler (ColumnToolTipTextChangedEvent, value); }
1807 remove { Events.RemoveHandler (ColumnToolTipTextChangedEvent, value); }
1810 public event DataGridViewColumnEventHandler ColumnWidthChanged {
1811 add { Events.AddHandler (ColumnWidthChangedEvent, value); }
1812 remove { Events.RemoveHandler (ColumnWidthChangedEvent, value); }
1815 public event EventHandler CurrentCellChanged {
1816 add { Events.AddHandler (CurrentCellChangedEvent, value); }
1817 remove { Events.RemoveHandler (CurrentCellChangedEvent, value); }
1820 [EditorBrowsable (EditorBrowsableState.Advanced)]
1821 public event EventHandler CurrentCellDirtyStateChanged {
1822 add { Events.AddHandler (CurrentCellDirtyStateChangedEvent, value); }
1823 remove { Events.RemoveHandler (CurrentCellDirtyStateChangedEvent, value); }
1826 public event DataGridViewBindingCompleteEventHandler DataBindingComplete {
1827 add { Events.AddHandler (DataBindingCompleteEvent, value); }
1828 remove { Events.RemoveHandler (DataBindingCompleteEvent, value); }
1831 public event DataGridViewDataErrorEventHandler DataError {
1832 add { Events.AddHandler (DataErrorEvent, value); }
1833 remove { Events.RemoveHandler (DataErrorEvent, value); }
1836 public event EventHandler DataMemberChanged {
1837 add { Events.AddHandler (DataMemberChangedEvent, value); }
1838 remove { Events.RemoveHandler (DataMemberChangedEvent, value); }
1841 public event EventHandler DataSourceChanged {
1842 add { Events.AddHandler (DataSourceChangedEvent, value); }
1843 remove { Events.RemoveHandler (DataSourceChangedEvent, value); }
1846 public event EventHandler DefaultCellStyleChanged {
1847 add { Events.AddHandler (DefaultCellStyleChangedEvent, value); }
1848 remove { Events.RemoveHandler (DefaultCellStyleChangedEvent, value); }
1851 [EditorBrowsable (EditorBrowsableState.Advanced)]
1852 public event DataGridViewRowEventHandler DefaultValuesNeeded {
1853 add { Events.AddHandler (DefaultValuesNeededEvent, value); }
1854 remove { Events.RemoveHandler (DefaultValuesNeededEvent, value); }
1857 public event DataGridViewEditingControlShowingEventHandler EditingControlShowing {
1858 add { Events.AddHandler (EditingControlShowingEvent, value); }
1859 remove { Events.RemoveHandler (EditingControlShowingEvent, value); }
1862 public event EventHandler EditModeChanged {
1863 add { Events.AddHandler (EditModeChangedEvent, value); }
1864 remove { Events.RemoveHandler (EditModeChangedEvent, value); }
1868 [EditorBrowsable (EditorBrowsableState.Advanced)]
1869 public new event EventHandler FontChanged {
1870 add { base.FontChanged += value; }
1871 remove { base.FontChanged -= value; }
1875 [EditorBrowsable (EditorBrowsableState.Advanced)]
1876 public new event EventHandler ForeColorChanged {
1877 add { base.ForeColorChanged += value; }
1878 remove { base.ForeColorChanged -= value; }
1882 [EditorBrowsable (EditorBrowsableState.Never)]
1883 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
1884 public new event EventHandler PaddingChanged {
1885 add { base.PaddingChanged += value; }
1886 remove { base.PaddingChanged -= value; }
1889 public event EventHandler GridColorChanged {
1890 add { Events.AddHandler (GridColorChangedEvent, value); }
1891 remove { Events.RemoveHandler (GridColorChangedEvent, value); }
1894 public event EventHandler MultiSelectChanged {
1895 add { Events.AddHandler (MultiSelectChangedEvent, value); }
1896 remove { Events.RemoveHandler (MultiSelectChangedEvent, value); }
1899 public event DataGridViewRowEventHandler NewRowNeeded {
1900 add { Events.AddHandler (NewRowNeededEvent, value); }
1901 remove { Events.RemoveHandler (NewRowNeededEvent, value); }
1904 public event EventHandler ReadOnlyChanged {
1905 add { Events.AddHandler (ReadOnlyChangedEvent, value); }
1906 remove { Events.RemoveHandler (ReadOnlyChangedEvent, value); }
1909 public event DataGridViewRowEventHandler RowContextMenuStripChanged {
1910 add { Events.AddHandler (RowContextMenuStripChangedEvent, value); }
1911 remove { Events.RemoveHandler (RowContextMenuStripChangedEvent, value); }
1914 [EditorBrowsable (EditorBrowsableState.Advanced)]
1915 public event DataGridViewRowContextMenuStripNeededEventHandler RowContextMenuStripNeeded {
1916 add { Events.AddHandler (RowContextMenuStripNeededEvent, value); }
1917 remove { Events.RemoveHandler (RowContextMenuStripNeededEvent, value); }
1920 public event DataGridViewRowEventHandler RowDefaultCellStyleChanged {
1921 add { Events.AddHandler (RowDefaultCellStyleChangedEvent, value); }
1922 remove { Events.RemoveHandler (RowDefaultCellStyleChangedEvent, value); }
1925 [EditorBrowsable (EditorBrowsableState.Advanced)]
1926 public event QuestionEventHandler RowDirtyStateNeeded {
1927 add { Events.AddHandler (RowDirtyStateNeededEvent, value); }
1928 remove { Events.RemoveHandler (RowDirtyStateNeededEvent, value); }
1931 public event DataGridViewRowDividerDoubleClickEventHandler RowDividerDoubleClick {
1932 add { Events.AddHandler (RowDividerDoubleClickEvent, value); }
1933 remove { Events.RemoveHandler (RowDividerDoubleClickEvent, value); }
1936 public event DataGridViewRowEventHandler RowDividerHeightChanged {
1937 add { Events.AddHandler (RowDividerHeightChangedEvent, value); }
1938 remove { Events.RemoveHandler (RowDividerHeightChangedEvent, value); }
1941 public event DataGridViewCellEventHandler RowEnter {
1942 add { Events.AddHandler (RowEnterEvent, value); }
1943 remove { Events.RemoveHandler (RowEnterEvent, value); }
1946 public event DataGridViewRowEventHandler RowErrorTextChanged {
1947 add { Events.AddHandler (RowErrorTextChangedEvent, value); }
1948 remove { Events.RemoveHandler (RowErrorTextChangedEvent, value); }
1951 [EditorBrowsable (EditorBrowsableState.Advanced)]
1952 public event DataGridViewRowErrorTextNeededEventHandler RowErrorTextNeeded {
1953 add { Events.AddHandler (RowErrorTextNeededEvent, value); }
1954 remove { Events.RemoveHandler (RowErrorTextNeededEvent, value); }
1957 public event DataGridViewRowEventHandler RowHeaderCellChanged {
1958 add { Events.AddHandler (RowHeaderCellChangedEvent, value); }
1959 remove { Events.RemoveHandler (RowHeaderCellChangedEvent, value); }
1962 public event DataGridViewCellMouseEventHandler RowHeaderMouseClick {
1963 add { Events.AddHandler (RowHeaderMouseClickEvent, value); }
1964 remove { Events.RemoveHandler (RowHeaderMouseClickEvent, value); }
1967 public event DataGridViewCellMouseEventHandler RowHeaderMouseDoubleClick {
1968 add { Events.AddHandler (RowHeaderMouseDoubleClickEvent, value); }
1969 remove { Events.RemoveHandler (RowHeaderMouseDoubleClickEvent, value); }
1972 public event EventHandler RowHeadersBorderStyleChanged {
1973 add { Events.AddHandler (RowHeadersBorderStyleChangedEvent, value); }
1974 remove { Events.RemoveHandler (RowHeadersBorderStyleChangedEvent, value); }
1977 public event EventHandler RowHeadersDefaultCellStyleChanged {
1978 add { Events.AddHandler (RowHeadersDefaultCellStyleChangedEvent, value); }
1979 remove { Events.RemoveHandler (RowHeadersDefaultCellStyleChangedEvent, value); }
1982 public event EventHandler RowHeadersWidthChanged {
1983 add { Events.AddHandler (RowHeadersWidthChangedEvent, value); }
1984 remove { Events.RemoveHandler (RowHeadersWidthChangedEvent, value); }
1987 public event DataGridViewAutoSizeModeEventHandler RowHeadersWidthSizeModeChanged {
1988 add { Events.AddHandler (RowHeadersWidthSizeModeChangedEvent, value); }
1989 remove { Events.RemoveHandler (RowHeadersWidthSizeModeChangedEvent, value); }
1992 public event DataGridViewRowEventHandler RowHeightChanged {
1993 add { Events.AddHandler (RowHeightChangedEvent, value); }
1994 remove { Events.RemoveHandler (RowHeightChangedEvent, value); }
1997 [EditorBrowsable (EditorBrowsableState.Advanced)]
1998 public event DataGridViewRowHeightInfoNeededEventHandler RowHeightInfoNeeded {
1999 add { Events.AddHandler (RowHeightInfoNeededEvent, value); }
2000 remove { Events.RemoveHandler (RowHeightInfoNeededEvent, value); }
2003 [EditorBrowsable (EditorBrowsableState.Advanced)]
2004 public event DataGridViewRowHeightInfoPushedEventHandler RowHeightInfoPushed {
2005 add { Events.AddHandler (RowHeightInfoPushedEvent, value); }
2006 remove { Events.RemoveHandler (RowHeightInfoPushedEvent, value); }
2009 public event DataGridViewCellEventHandler RowLeave {
2010 add { Events.AddHandler (RowLeaveEvent, value); }
2011 remove { Events.RemoveHandler (RowLeaveEvent, value); }
2014 public event DataGridViewRowEventHandler RowMinimumHeightChanged {
2015 add { Events.AddHandler (RowMinimumHeightChangedEvent, value); }
2016 remove { Events.RemoveHandler (RowMinimumHeightChangedEvent, value); }
2019 public event DataGridViewRowPostPaintEventHandler RowPostPaint {
2020 add { Events.AddHandler (RowPostPaintEvent, value); }
2021 remove { Events.RemoveHandler (RowPostPaintEvent, value); }
2024 public event DataGridViewRowPrePaintEventHandler RowPrePaint {
2025 add { Events.AddHandler (RowPrePaintEvent, value); }
2026 remove { Events.RemoveHandler (RowPrePaintEvent, value); }
2029 public event DataGridViewRowsAddedEventHandler RowsAdded {
2030 add { Events.AddHandler (RowsAddedEvent, value); }
2031 remove { Events.RemoveHandler (RowsAddedEvent, value); }
2034 public event EventHandler RowsDefaultCellStyleChanged {
2035 add { Events.AddHandler (RowsDefaultCellStyleChangedEvent, value); }
2036 remove { Events.RemoveHandler (RowsDefaultCellStyleChangedEvent, value); }
2039 public event DataGridViewRowsRemovedEventHandler RowsRemoved {
2040 add { Events.AddHandler (RowsRemovedEvent, value); }
2041 remove { Events.RemoveHandler (RowsRemovedEvent, value); }
2044 public event DataGridViewRowStateChangedEventHandler RowStateChanged {
2045 add { Events.AddHandler (RowStateChangedEvent, value); }
2046 remove { Events.RemoveHandler (RowStateChangedEvent, value); }
2049 [EditorBrowsable (EditorBrowsableState.Advanced)]
2050 public event DataGridViewRowEventHandler RowUnshared {
2051 add { Events.AddHandler (RowUnsharedEvent, value); }
2052 remove { Events.RemoveHandler (RowUnsharedEvent, value); }
2055 public event DataGridViewCellEventHandler RowValidated {
2056 add { Events.AddHandler (RowValidatedEvent, value); }
2057 remove { Events.RemoveHandler (RowValidatedEvent, value); }
2060 public event DataGridViewCellCancelEventHandler RowValidating {
2061 add { Events.AddHandler (RowValidatingEvent, value); }
2062 remove { Events.RemoveHandler (RowValidatingEvent, value); }
2065 public event ScrollEventHandler Scroll {
2066 add { Events.AddHandler (ScrollEvent, value); }
2067 remove { Events.RemoveHandler (ScrollEvent, value); }
2070 public event EventHandler SelectionChanged {
2071 add { Events.AddHandler (SelectionChangedEvent, value); }
2072 remove { Events.RemoveHandler (SelectionChangedEvent, value); }
2075 [EditorBrowsable (EditorBrowsableState.Advanced)]
2076 public event DataGridViewSortCompareEventHandler SortCompare {
2077 add { Events.AddHandler (SortCompareEvent, value); }
2078 remove { Events.RemoveHandler (SortCompareEvent, value); }
2081 public event EventHandler Sorted {
2082 add { Events.AddHandler (SortedEvent, value); }
2083 remove { Events.RemoveHandler (SortedEvent, value); }
2086 public event DataGridViewRowEventHandler UserAddedRow {
2087 add { Events.AddHandler (UserAddedRowEvent, value); }
2088 remove { Events.RemoveHandler (UserAddedRowEvent, value); }
2091 public event DataGridViewRowEventHandler UserDeletedRow {
2092 add { Events.AddHandler (UserDeletedRowEvent, value); }
2093 remove { Events.RemoveHandler (UserDeletedRowEvent, value); }
2096 public event DataGridViewRowCancelEventHandler UserDeletingRow {
2097 add { Events.AddHandler (UserDeletingRowEvent, value); }
2098 remove { Events.RemoveHandler (UserDeletingRowEvent, value); }
2102 [EditorBrowsable (EditorBrowsableState.Never)]
2103 public new event EventHandler StyleChanged {
2104 add { base.StyleChanged += value; }
2105 remove { base.StyleChanged -= value; }
2109 [EditorBrowsable (EditorBrowsableState.Never)]
2110 public new event EventHandler TextChanged {
2111 add { base.TextChanged += value; }
2112 remove { base.TextChanged -= value; }
2115 [EditorBrowsable (EditorBrowsableState.Advanced)]
2116 public virtual DataGridViewAdvancedBorderStyle AdjustColumnHeaderBorderStyle (DataGridViewAdvancedBorderStyle dataGridViewAdvancedBorderStyleInput, DataGridViewAdvancedBorderStyle dataGridViewAdvancedBorderStylePlaceholder, bool isFirstDisplayedColumn, bool isLastVisibleColumn) {
2117 return (DataGridViewAdvancedBorderStyle) ((ICloneable)dataGridViewAdvancedBorderStyleInput).Clone();
2120 public bool AreAllCellsSelected (bool includeInvisibleCells) {
2121 foreach (DataGridViewRow row in rows) {
2122 foreach (DataGridViewCell cell in row.Cells) {
2123 if (includeInvisibleCells == false && cell.Visible == false) {
2126 if (!cell.Selected) {
2134 public void AutoResizeColumn (int columnIndex) {
2135 AutoResizeColumn (columnIndex, DataGridViewAutoSizeColumnMode.AllCells);
2138 public void AutoResizeColumn (int columnIndex, DataGridViewAutoSizeColumnMode autoSizeColumnMode)
2140 AutoResizeColumnInternal (columnIndex, autoSizeColumnMode);
2143 public void AutoResizeColumnHeadersHeight ()
2147 foreach (DataGridViewColumn col in Columns)
2148 new_height = Math.Max (new_height, col.HeaderCell.PreferredSize.Height);
2150 if (ColumnHeadersHeight != new_height)
2151 ColumnHeadersHeight = new_height;
2154 [MonoTODO ("columnIndex parameter is not used")]
2155 public void AutoResizeColumnHeadersHeight (int columnIndex)
2157 AutoResizeColumnHeadersHeight ();
2160 public void AutoResizeColumns () {
2161 AutoResizeColumns (DataGridViewAutoSizeColumnsMode.AllCells);
2164 public void AutoResizeColumns (DataGridViewAutoSizeColumnsMode autoSizeColumnsMode) {
2165 AutoResizeColumns (autoSizeColumnsMode, true);
2168 public void AutoResizeRow (int rowIndex)
2170 AutoResizeRow (rowIndex, DataGridViewAutoSizeRowMode.AllCells, true);
2173 public void AutoResizeRow (int rowIndex, DataGridViewAutoSizeRowMode autoSizeRowMode)
2175 AutoResizeRow (rowIndex, autoSizeRowMode, true);
2178 public void AutoResizeRowHeadersWidth (DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode)
2180 if (rowHeadersWidthSizeMode == DataGridViewRowHeadersWidthSizeMode.AutoSizeToFirstHeader) {
2181 RowHeadersWidth = GetRowInternal (0).HeaderCell.PreferredSize.Width;
2187 if (rowHeadersWidthSizeMode == DataGridViewRowHeadersWidthSizeMode.AutoSizeToDisplayedHeaders) {
2188 foreach (DataGridViewRow row in Rows)
2190 new_width = Math.Max (new_width, row.HeaderCell.PreferredSize.Width);
2192 if (RowHeadersWidth != new_width)
2193 RowHeadersWidth = new_width;
2198 if (rowHeadersWidthSizeMode == DataGridViewRowHeadersWidthSizeMode.AutoSizeToAllHeaders) {
2199 foreach (DataGridViewRow row in Rows)
2200 new_width = Math.Max (new_width, row.HeaderCell.PreferredSize.Width);
2202 if (RowHeadersWidth != new_width)
2203 RowHeadersWidth = new_width;
2209 [MonoTODO ("Does not use rowIndex parameter.")]
2210 public void AutoResizeRowHeadersWidth (int rowIndex, DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode)
2212 AutoResizeRowHeadersWidth (rowHeadersWidthSizeMode);
2215 public void AutoResizeRows ()
2217 AutoResizeRows (0, Rows.Count, DataGridViewAutoSizeRowMode.AllCells, false);
2220 public void AutoResizeRows (DataGridViewAutoSizeRowsMode autoSizeRowsMode)
2222 if (!Enum.IsDefined(typeof(DataGridViewAutoSizeRowsMode), autoSizeRowsMode))
2223 throw new InvalidEnumArgumentException ("Parameter autoSizeRowsMode is not a valid DataGridViewRowsMode.");
2224 if ((autoSizeRowsMode == DataGridViewAutoSizeRowsMode.AllHeaders || autoSizeRowsMode == DataGridViewAutoSizeRowsMode.DisplayedHeaders) && rowHeadersVisible == false)
2225 throw new InvalidOperationException ("Parameter autoSizeRowsMode cannot be AllHeaders or DisplayedHeaders in this DataGridView.");
2226 if (autoSizeRowsMode == DataGridViewAutoSizeRowsMode.None)
2227 throw new ArgumentException ("Parameter autoSizeRowsMode cannot be None.");
2229 AutoResizeRows (autoSizeRowsMode, false);
2232 public virtual bool BeginEdit (bool selectAll) {
2233 if (currentCell == null || currentCell.IsInEditMode)
2236 if (currentCell.RowIndex >= 0) {
2237 if ((currentCell.InheritedState & DataGridViewElementStates.ReadOnly) == DataGridViewElementStates.ReadOnly) {
2242 DataGridViewCell cell = currentCell;
2243 Type editType = cell.EditType;
2245 if (editType == null && !(cell is IDataGridViewEditingCell))
2248 // Give user a chance to cancel the edit
2249 DataGridViewCellCancelEventArgs e = new DataGridViewCellCancelEventArgs (cell.ColumnIndex, cell.RowIndex);
2250 OnCellBeginEdit (e);
2255 // If the user begins an edit in the NewRow, add a new row
2256 if (CurrentCell.RowIndex == NewRowIndex) {
2257 new_row_commited = false;
2258 OnUserAddedRow (new DataGridViewRowEventArgs (Rows[NewRowIndex]));
2261 cell.SetIsInEditMode (true);
2263 // The cell has an editing control we need to setup
2264 if (editType != null) {
2265 Control ctrl = EditingControlInternal;
2267 // Check if we can reuse the one we already have
2268 bool isCorrectType = ctrl != null && ctrl.GetType () == editType;
2273 // We couldn't use the existing one, create a new one
2275 ctrl = (Control) Activator.CreateInstance (editType);
2276 EditingControlInternal = ctrl;
2279 // Call some functions that allows the editing control to get setup
2280 DataGridViewCellStyle style = cell.RowIndex == -1 ? DefaultCellStyle : cell.InheritedStyle;
2282 cell.InitializeEditingControl (cell.RowIndex, cell.FormattedValue, style);
2283 cell.PositionEditingControl (true, true, this.GetCellDisplayRectangle (cell.ColumnIndex, cell.RowIndex, false), bounds, style, false, false, (columns [cell.ColumnIndex].DisplayIndex == 0), (cell.RowIndex == 0));
2285 // Show the editing control
2286 EditingControlInternal.Visible = true;
2288 // Allow editing control to set focus as needed
2289 (EditingControlInternal as IDataGridViewEditingControl).PrepareEditingControlForEdit (selectAll);
2294 // If we are here, it means we have a cell that does not have an editing control
2295 // and simply implements IDataGridViewEditingCell itself.
2296 (cell as IDataGridViewEditingCell).PrepareEditingCellForEdit (selectAll);
2301 public bool CancelEdit ()
2303 if (currentCell != null && currentCell.IsInEditMode) {
2304 // The user's typing caused a new row to be created, but
2305 // now they are canceling that typing, we have to remove
2306 // the new row we added.
2307 if (!new_row_commited) {
2308 DataGridViewRow delete_row = EditingRow;
2309 Rows.RemoveInternal (delete_row);
2310 editing_row = Rows[currentCell.RowIndex];
2311 OnUserDeletedRow (new DataGridViewRowEventArgs (delete_row));
2312 new_row_commited = true;
2315 currentCell.SetIsInEditMode (false);
2316 currentCell.DetachEditingControl ();
2317 OnCellEndEdit (new DataGridViewCellEventArgs (currentCell.ColumnIndex, currentCell.RowIndex));
2323 public void ClearSelection ()
2325 foreach (DataGridViewColumn col in SelectedColumns)
2326 col.Selected = false;
2327 foreach (DataGridViewRow row in SelectedRows)
2328 row.Selected = false;
2329 foreach (DataGridViewCell cell in SelectedCells)
2330 cell.Selected = false;
2333 public bool CommitEdit (DataGridViewDataErrorContexts context)
2335 if (currentCell != null && currentCell.IsInEditMode) {
2336 IDataGridViewEditingControl ctrl = EditingControl as IDataGridViewEditingControl;
2337 ctrl.GetEditingControlFormattedValue (DataGridViewDataErrorContexts.Commit);
2338 currentCell.Value = ctrl.GetEditingControlFormattedValue (DataGridViewDataErrorContexts.Commit);
2345 [MonoTODO ("Always includes partial columns")]
2346 public int DisplayedColumnCount (bool includePartialColumns)
2350 for (int i = first_col_index; i < Columns.Count; i++)
2351 if (Columns.ColumnDisplayIndexSortedArrayList[i].Displayed)
2359 public int DisplayedRowCount (bool includePartialRow)
2364 if (ColumnHeadersVisible)
2365 rowTop += ColumnHeadersHeight;
2367 for (int index = first_row_index; index < Rows.Count; index++) {
2368 DataGridViewRow row = GetRowInternal (index);
2369 if (rowTop + row.Height < ClientSize.Height) {
2371 rowTop += row.Height;
2373 if (includePartialRow)
2382 public bool EndEdit ()
2384 if (currentCell != null && currentCell.IsInEditMode) {
2385 if (EditingControl != null) {
2386 IDataGridViewEditingControl ctrl = EditingControl as IDataGridViewEditingControl;
2387 ctrl.GetEditingControlFormattedValue (DataGridViewDataErrorContexts.Commit);
2388 currentCell.Value = ctrl.GetEditingControlFormattedValue (DataGridViewDataErrorContexts.Commit);
2390 currentCell.SetIsInEditMode (false);
2391 currentCell.DetachEditingControl ();
2392 } else if (currentCell is IDataGridViewEditingCell) {
2393 currentCell.Value = (currentCell as IDataGridViewEditingCell).EditingCellFormattedValue;
2394 currentCell.SetIsInEditMode (false);
2397 new_row_commited = true;
2398 OnCellEndEdit (new DataGridViewCellEventArgs (currentCell.ColumnIndex, currentCell.RowIndex));
2404 [MonoTODO ("Does not use context parameter")]
2405 public bool EndEdit (DataGridViewDataErrorContexts context)
2410 public int GetCellCount (DataGridViewElementStates includeFilter) {
2412 foreach (DataGridViewRow row in rows) {
2413 foreach (DataGridViewCell cell in row.Cells) {
2414 if ((cell.State & includeFilter) != 0) {
2422 internal DataGridViewRow GetRowInternal (int rowIndex)
2424 return Rows.SharedRow (rowIndex);
2427 internal DataGridViewCell GetCellInternal (int colIndex, int rowIndex)
2429 return GetRowInternal (rowIndex).Cells.GetCellInternal (colIndex);
2432 public Rectangle GetCellDisplayRectangle (int columnIndex, int rowIndex, bool cutOverflow) {
2433 if (columnIndex < 0 || columnIndex >= columns.Count) {
2434 throw new ArgumentOutOfRangeException("Column index is out of range.");
2437 int x = 0, y = 0, w = 0, h = 0;
2442 if (ColumnHeadersVisible)
2443 y += ColumnHeadersHeight;
2445 if (RowHeadersVisible)
2446 x += RowHeadersWidth;
2448 List<DataGridViewColumn> cols = columns.ColumnDisplayIndexSortedArrayList;
2450 for (int i = first_col_index; i < cols.Count; i++) {
2451 if (!cols[i].Visible)
2454 if (cols[i].Index == columnIndex) {
2462 for (int i = first_row_index; i < Rows.Count; i++) {
2463 if (i == rowIndex) {
2464 h = rows [i].Height;
2468 y += rows [i].Height;
2471 return new Rectangle (x, y, w, h);
2474 public virtual DataObject GetClipboardContent () {
2476 if (clipboardCopyMode == DataGridViewClipboardCopyMode.Disable)
2477 throw new InvalidOperationException ("Generating Clipboard content is not supported when the ClipboardCopyMode property is Disable.");
2479 int start_row = int.MaxValue, end_row = int.MinValue;
2480 int start_col = int.MaxValue, end_col = int.MinValue;
2482 bool include_row_headers = false;
2483 bool include_col_headers = false;
2484 bool only_included_headers = false;
2485 bool headers_includable = false;
2487 switch (ClipboardCopyMode) {
2488 case DataGridViewClipboardCopyMode.EnableWithoutHeaderText:
2490 case DataGridViewClipboardCopyMode.EnableWithAutoHeaderText:
2491 // Headers are included if not selection mode is CellSelect, and any header is selected.
2492 headers_includable = selectionMode != DataGridViewSelectionMode.CellSelect;
2494 case DataGridViewClipboardCopyMode.EnableAlwaysIncludeHeaderText:
2495 include_col_headers = include_row_headers = true;
2499 BitArray included_rows = new BitArray (RowCount);
2500 BitArray included_cols = new BitArray (ColumnCount);
2502 // If there are any selected columns,
2503 // include the column headers (if headers are to be shown).
2504 if (headers_includable && !include_col_headers) {
2505 for (int c = 0; c < ColumnCount; c++) {
2506 if (Columns [c].Selected) {
2507 include_col_headers = true;
2513 // Find the smallest rectangle that encompasses all selected cells.
2514 for (int r = 0; r < RowCount; r++) {
2515 DataGridViewRow row = Rows [r];
2517 if (headers_includable && !include_row_headers && row.Selected) {
2518 include_row_headers = true;
2521 for (int c = 0; c < ColumnCount; c++) {
2522 DataGridViewCell cell = row.Cells [c];
2524 if (cell == null || !cell.Selected)
2527 included_cols [c] = true;
2528 included_rows [r] = true;
2530 start_row = Math.Min (start_row, r);
2531 start_col = Math.Min (start_col, c);
2532 end_row = Math.Max (end_row, r);
2533 end_col = Math.Max (end_col, c);
2537 // Mark rows/columns in between selected cells as included if the selection mode isn't FullHeaderSelect.
2538 switch (selectionMode){
2539 case DataGridViewSelectionMode.CellSelect:
2540 case DataGridViewSelectionMode.ColumnHeaderSelect:
2541 case DataGridViewSelectionMode.RowHeaderSelect:
2542 if (selectionMode != DataGridViewSelectionMode.ColumnHeaderSelect) {
2543 for (int r = start_row; r <= end_row; r++) {
2544 included_rows.Set (r, true);
2546 } else if (start_row <= end_row) {
2547 included_rows.SetAll (true);
2549 if (selectionMode != DataGridViewSelectionMode.RowHeaderSelect) {
2550 for (int c = start_col; c <= end_col; c++) {
2551 included_cols.Set (c, true);
2555 case DataGridViewSelectionMode.FullColumnSelect:
2556 case DataGridViewSelectionMode.FullRowSelect:
2557 only_included_headers = true;
2561 if (start_row > end_row)
2564 if (start_col > end_col)
2567 DataObject result = new DataObject ();
2569 System.Text.StringBuilder text_builder = new System.Text.StringBuilder ();
2570 System.Text.StringBuilder utext_builder = new System.Text.StringBuilder ();
2571 System.Text.StringBuilder html_builder = new System.Text.StringBuilder ();
2572 System.Text.StringBuilder csv_builder = new System.Text.StringBuilder ();
2574 // Loop through all rows and columns to create the content.
2575 // -1 is the header row/column.
2576 int first_row = start_row;
2577 int first_col = start_col;
2578 if (include_col_headers) {
2581 for (int r = first_row; r <= end_row; r++) {
2582 DataGridViewRow row = null;
2585 if (!included_rows [r])
2591 if (include_row_headers) {
2595 for (int c = first_col; c <= end_col; c++) {
2596 DataGridViewCell cell = null;
2598 if (c >= 0 && only_included_headers && !included_cols [c])
2603 cell = TopLeftHeaderCell;
2605 cell = Columns [c].HeaderCell;
2609 cell = row.HeaderCell;
2611 cell = row.Cells [c];
2615 string text, utext, html, csv;
2616 bool is_first_cell = (c == first_col);
2617 bool is_last_cell = (c == end_col);
2618 bool is_first_row = (r == first_row);
2619 bool is_last_row = (r == end_row);
2622 text = string.Empty;
2623 utext = string.Empty;
2624 html = string.Empty;
2627 text = cell.GetClipboardContentInternal (r, is_first_cell, is_last_cell, is_first_row, is_last_row, DataFormats.Text) as string;
2628 utext = cell.GetClipboardContentInternal (r, is_first_cell, is_last_cell, is_first_row, is_last_row, DataFormats.UnicodeText) as string;
2629 html = cell.GetClipboardContentInternal (r, is_first_cell, is_last_cell, is_first_row, is_last_row, DataFormats.Html) as string;
2630 csv = cell.GetClipboardContentInternal (r, is_first_cell, is_last_cell, is_first_row, is_last_row, DataFormats.CommaSeparatedValue) as string;
2633 text_builder.Append (text);
2634 utext_builder.Append (utext);
2635 html_builder.Append (html);
2636 csv_builder.Append (csv);
2638 if (c == -1) { // If we just did the row header, jump to the first column.
2643 if (r == -1) {// If we just did the column header, jump to the first row.
2649 // Html content always get the \r\n newline
2650 // It's valid html anyway, and it eases testing quite a bit
2651 // (since otherwise we'd have to change the start indices
2652 // in the added prologue/epilogue text)
2654 int fragment_end = 135 + html_builder.Length;
2655 int html_end = fragment_end + 36;
2658 "StartHTML:00000097{0}" +
2659 "EndHTML:{1:00000000}{0}" +
2660 "StartFragment:00000133{0}" +
2661 "EndFragment:{2:00000000}{0}" +
2664 "<!--StartFragment-->";
2666 html_start = string.Format (html_start, "\r\n", html_end, fragment_end);
2667 html_builder.Insert (0, html_start);
2668 html_builder.AppendFormat ("{0}<!--EndFragment-->{0}</BODY>{0}</HTML>", "\r\n");
2670 result.SetData (DataFormats.CommaSeparatedValue, false, csv_builder.ToString ());
2671 result.SetData (DataFormats.Html, false, html_builder.ToString ());
2672 result.SetData (DataFormats.UnicodeText, false, utext_builder.ToString ());
2673 result.SetData (DataFormats.Text, false, text_builder.ToString ());
2678 [MonoTODO ("Does not use cutOverflow parameter")]
2679 public Rectangle GetColumnDisplayRectangle (int columnIndex, bool cutOverflow)
2681 if (columnIndex < 0 || columnIndex > Columns.Count - 1)
2682 throw new ArgumentOutOfRangeException ("columnIndex");
2689 if (RowHeadersVisible)
2690 x += RowHeadersWidth;
2692 List<DataGridViewColumn> cols = columns.ColumnDisplayIndexSortedArrayList;
2694 for (int i = first_col_index; i < cols.Count; i++) {
2695 if (!cols[i].Visible)
2698 if (cols[i].Index == columnIndex) {
2706 return new Rectangle (x, 0, w, Height);
2709 [MonoTODO ("Does not use cutOverflow parameter")]
2710 public Rectangle GetRowDisplayRectangle (int rowIndex, bool cutOverflow)
2712 if (rowIndex < 0 || rowIndex > Rows.Count - 1)
2713 throw new ArgumentOutOfRangeException ("rowIndex");
2720 if (ColumnHeadersVisible)
2721 y += ColumnHeadersHeight;
2723 for (int i = first_row_index; i < Rows.Count; i++) {
2724 if (i == rowIndex) {
2729 y += rows[i].Height;
2732 return new Rectangle (0, y, Width, h);
2735 public HitTestInfo HitTest (int x, int y) {
2736 ///////////////////////////////////////////////////////
2737 //Console.WriteLine ("HitTest ({0}, {1})", x, y);
2738 bool isInColHeader = columnHeadersVisible && y >= 0 && y <= ColumnHeadersHeight;
2739 bool isInRowHeader = rowHeadersVisible && x >= 0 && x <= RowHeadersWidth;
2742 if (isInColHeader && isInRowHeader)
2743 return new HitTestInfo (-1, x, -1, y, DataGridViewHitTestType.TopLeftHeader);
2745 // HorizontalScrollBar
2746 if (horizontalScrollBar.Visible && horizontalScrollBar.Bounds.Contains (x, y))
2747 return new HitTestInfo (-1, x, -1, y, DataGridViewHitTestType.HorizontalScrollBar);
2749 // VerticalScrollBar
2750 if (verticalScrollBar.Visible && verticalScrollBar.Bounds.Contains (x, y))
2751 return new HitTestInfo (-1, x, -1, y, DataGridViewHitTestType.VerticalScrollBar);
2753 // The little box in the bottom right if both scrollbars are shown is None
2754 if (verticalScrollBar.Visible && horizontalScrollBar.Visible)
2755 if (new Rectangle (verticalScrollBar.Left, horizontalScrollBar.Top, verticalScrollBar.Width, horizontalScrollBar.Height).Contains (x, y))
2756 return new HitTestInfo (-1, x, -1, y, DataGridViewHitTestType.None);
2761 int top = columnHeadersVisible ? columnHeadersHeight : 0;
2763 for (int i = first_row_index; i < Rows.Count; i++) {
2764 DataGridViewRow row = Rows[i];
2766 if (y > top && y <= (top + row.Height)) {
2774 int left = rowHeadersVisible ? RowHeadersWidth : 0;
2776 List<DataGridViewColumn> cols = columns.ColumnDisplayIndexSortedArrayList;
2778 for (int i = first_col_index; i < cols.Count; i++) {
2779 if (!cols[i].Visible)
2782 if (x > left && x <= (left + cols[i].Width)) {
2783 colindex = cols[i].Index;
2787 left += cols[i].Width;
2790 if (colindex >= 0 && rowindex >= 0)
2791 return new HitTestInfo (colindex, x, rowindex, y, DataGridViewHitTestType.Cell);
2793 if (isInColHeader && colindex > -1)
2794 return new HitTestInfo (colindex, x, rowindex, y, DataGridViewHitTestType.ColumnHeader);
2796 if (isInRowHeader && rowindex > -1)
2797 return new HitTestInfo (colindex, x, rowindex, y, DataGridViewHitTestType.RowHeader);
2799 return new HitTestInfo (-1, x, -1, y, DataGridViewHitTestType.None);
2802 [MonoTODO ("Invalidates whole grid")]
2803 public void InvalidateCell (DataGridViewCell dataGridViewCell)
2805 if (dataGridViewCell == null)
2806 throw new ArgumentNullException ("Cell is null");
2808 if (dataGridViewCell.DataGridView != this)
2809 throw new ArgumentException ("The specified cell does not belong to this DataGridView.");
2811 InvalidateCell (dataGridViewCell.ColumnIndex, dataGridViewCell.RowIndex);
2814 [MonoTODO ("Invalidates whole grid")]
2815 public void InvalidateCell (int columnIndex, int rowIndex)
2817 if (columnIndex < 0 || columnIndex >= columns.Count)
2818 throw new ArgumentOutOfRangeException ("Column index is out of range.");
2820 if (rowIndex < 0 || rowIndex >= rows.Count)
2821 throw new ArgumentOutOfRangeException ("Row index is out of range.");
2823 Invalidate (GetCellDisplayRectangle (columnIndex, rowIndex, true));
2826 [MonoTODO ("Invalidates whole grid")]
2827 public void InvalidateColumn (int columnIndex)
2829 if (columnIndex < 0 || columnIndex >= columns.Count)
2830 throw new ArgumentOutOfRangeException ("Column index is out of range.");
2832 Invalidate (GetColumnDisplayRectangle (columnIndex, true));
2835 [MonoTODO ("Invalidates whole grid")]
2836 public void InvalidateRow (int rowIndex)
2838 if (rowIndex < 0 || rowIndex >= rows.Count)
2839 throw new ArgumentOutOfRangeException ("Row index is out of range.");
2841 Invalidate (GetRowDisplayRectangle (rowIndex, true));
2844 public virtual void NotifyCurrentCellDirty (bool dirty) {
2845 throw new NotImplementedException();
2848 public bool RefreshEdit ()
2850 if (IsCurrentCellInEditMode) {
2851 currentCell.InitializeEditingControl (currentCell.RowIndex, currentCell.FormattedValue, currentCell.InheritedStyle);
2858 [EditorBrowsable (EditorBrowsableState.Never)]
2859 public override void ResetText ()
2861 Text = string.Empty;
2864 public void SelectAll () {
2865 switch (selectionMode) {
2866 case DataGridViewSelectionMode.FullRowSelect:
2867 foreach (DataGridViewRow row in rows) {
2868 (row as DataGridViewBand).Selected = true;
2871 case DataGridViewSelectionMode.FullColumnSelect:
2872 foreach (DataGridViewColumn col in columns) {
2873 (col as DataGridViewBand).Selected = true;
2877 foreach (DataGridViewRow row in rows) {
2878 foreach (DataGridViewCell cell in row.Cells) {
2879 cell.Selected = true;
2888 public virtual void Sort (IComparer comparer)
2890 if (comparer == null)
2891 throw new ArgumentNullException ("comparer");
2892 if (VirtualMode || DataSource != null)
2893 throw new InvalidOperationException ();
2895 if (SortedColumn != null)
2896 SortedColumn.HeaderCell.SortGlyphDirection = SortOrder.None;
2900 Rows.Sort (comparer);
2902 sortedColumn = null;
2903 sortOrder = SortOrder.None;
2909 OnSorted (EventArgs.Empty);
2912 public virtual void Sort (DataGridViewColumn dataGridViewColumn, ListSortDirection direction)
2914 if (dataGridViewColumn == null)
2915 throw new ArgumentNullException ("dataGridViewColumn");
2916 if (dataGridViewColumn.DataGridView != this)
2917 throw new ArgumentException ("dataGridViewColumn");
2918 // XXX: This is thrown too much, disable for now..
2919 //if (DataSource != null && !dataGridViewColumn.IsDataBound)
2920 // throw new ArgumentException ("dataGridViewColumn");
2921 //if (VirtualMode && !dataGridViewColumn.IsDataBound)
2922 // throw new InvalidOperationException ();
2924 if (SortedColumn != null)
2925 SortedColumn.HeaderCell.SortGlyphDirection = SortOrder.None;
2929 // Figure out if this is a numeric sort or text sort
2930 bool is_numeric = true;
2933 foreach (DataGridViewRow row in Rows) {
2934 object val = row.Cells[dataGridViewColumn.Index].Value;
2936 if (val != null && !double.TryParse (val.ToString (), out n)) {
2942 ColumnSorter sorter = new ColumnSorter (dataGridViewColumn, direction, is_numeric);
2945 sortedColumn = dataGridViewColumn;
2946 sortOrder = (SortOrder)direction + 1;
2948 dataGridViewColumn.HeaderCell.SortGlyphDirection = (SortOrder)direction + 1;
2952 OnSorted (EventArgs.Empty);
2955 public void UpdateCellErrorText (int columnIndex, int rowIndex)
2957 if (columnIndex < 0 || columnIndex > Columns.Count - 1)
2958 throw new ArgumentOutOfRangeException ("columnIndex");
2959 if (rowIndex < 0 || rowIndex > Rows.Count - 1)
2960 throw new ArgumentOutOfRangeException ("rowIndex");
2962 InvalidateCell (columnIndex, rowIndex);
2965 public void UpdateCellValue (int columnIndex, int rowIndex)
2967 if (columnIndex < 0 || columnIndex > Columns.Count - 1)
2968 throw new ArgumentOutOfRangeException ("columnIndex");
2969 if (rowIndex < 0 || rowIndex > Rows.Count - 1)
2970 throw new ArgumentOutOfRangeException ("rowIndex");
2972 InvalidateCell (columnIndex, rowIndex);
2975 public void UpdateRowErrorText (int rowIndex)
2977 if (rowIndex < 0 || rowIndex > Rows.Count - 1)
2978 throw new ArgumentOutOfRangeException ("rowIndex");
2980 InvalidateRow (rowIndex);
2983 public void UpdateRowErrorText (int rowIndexStart, int rowIndexEnd)
2985 if (rowIndexStart < 0 || rowIndexStart > Rows.Count - 1)
2986 throw new ArgumentOutOfRangeException ("rowIndexStart");
2987 if (rowIndexEnd < 0 || rowIndexEnd > Rows.Count - 1)
2988 throw new ArgumentOutOfRangeException ("rowIndexEnd");
2989 if (rowIndexEnd < rowIndexStart)
2990 throw new ArgumentOutOfRangeException ("rowIndexEnd", "rowIndexEnd must be greater than rowIndexStart");
2992 for (int i = rowIndexStart; i <= rowIndexEnd; i++)
2996 public void UpdateRowHeightInfo (int rowIndex, bool updateToEnd) {
2997 throw new NotImplementedException();
3000 protected override bool CanEnableIme {
3002 if (CurrentCell != null && CurrentCell.EditType != null)
3009 protected override Size DefaultSize {
3010 get { return new Size (240, 150); }
3013 protected ScrollBar HorizontalScrollBar {
3014 get { return horizontalScrollBar; }
3017 protected ScrollBar VerticalScrollBar {
3018 get { return verticalScrollBar; }
3021 protected virtual void AccessibilityNotifyCurrentCellChanged (Point cellAddress)
3023 throw new NotImplementedException ();
3026 [MonoTODO ("Does not use fixedHeight parameter")]
3027 protected void AutoResizeColumn (int columnIndex, DataGridViewAutoSizeColumnMode autoSizeColumnMode, bool fixedHeight)
3029 AutoResizeColumn (columnIndex, autoSizeColumnMode);
3032 [MonoTODO ("Does not use fixedRowHeadersWidth or fixedColumnsWidth parameters")]
3033 protected void AutoResizeColumnHeadersHeight (bool fixedRowHeadersWidth, bool fixedColumnsWidth)
3035 AutoResizeColumnHeadersHeight ();
3038 [MonoTODO ("Does not use columnIndex or fixedRowHeadersWidth or fixedColumnsWidth parameters")]
3039 protected void AutoResizeColumnHeadersHeight (int columnIndex, bool fixedRowHeadersWidth, bool fixedColumnWidth)
3041 AutoResizeColumnHeadersHeight (columnIndex);
3044 protected void AutoResizeColumns (DataGridViewAutoSizeColumnsMode autoSizeColumnsMode, bool fixedHeight) {
3045 for (int i = 0; i < Columns.Count; i++) {
3046 AutoResizeColumn (i, (DataGridViewAutoSizeColumnMode) autoSizeColumnsMode, fixedHeight);
3050 [MonoTODO ("Does not use fixedWidth parameter")]
3051 protected void AutoResizeRow (int rowIndex, DataGridViewAutoSizeRowMode autoSizeRowMode, bool fixedWidth)
3053 if (autoSizeRowMode == DataGridViewAutoSizeRowMode.RowHeader && !rowHeadersVisible)
3054 throw new InvalidOperationException ("row headers are not visible");
3055 if (rowIndex < 0 || rowIndex > Rows.Count - 1)
3056 throw new ArgumentOutOfRangeException ("rowIndex");
3058 DataGridViewRow row = GetRowInternal (rowIndex);
3060 int new_height = row.GetPreferredHeight (rowIndex, autoSizeRowMode, true);
3062 if (row.Height != new_height)
3063 row.SetAutoSizeHeight (new_height);
3066 [MonoTODO ("Does not use fixedColumnHeadersHeight or fixedRowsHeight parameter")]
3067 protected void AutoResizeRowHeadersWidth (DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode, bool fixedColumnHeadersHeight, bool fixedRowsHeight)
3069 AutoResizeRowHeadersWidth (rowHeadersWidthSizeMode);
3072 [MonoTODO ("Does not use rowIndex or fixedColumnHeadersHeight or fixedRowsHeight parameter")]
3073 protected void AutoResizeRowHeadersWidth (int rowIndex, DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode, bool fixedColumnHeadersHeight, bool fixedRowHeight)
3075 AutoResizeRowHeadersWidth (rowHeadersWidthSizeMode);
3078 [MonoTODO ("Does not use fixedWidth parameter")]
3079 protected void AutoResizeRows (DataGridViewAutoSizeRowsMode autoSizeRowsMode, bool fixedWidth)
3081 if (autoSizeRowsMode == DataGridViewAutoSizeRowsMode.None)
3084 bool displayed_only = false;
3085 DataGridViewAutoSizeRowMode mode = DataGridViewAutoSizeRowMode.AllCells;
3087 switch (autoSizeRowsMode) {
3088 case DataGridViewAutoSizeRowsMode.AllHeaders:
3089 mode = DataGridViewAutoSizeRowMode.RowHeader;
3091 case DataGridViewAutoSizeRowsMode.AllCellsExceptHeaders:
3092 mode = DataGridViewAutoSizeRowMode.AllCellsExceptHeader;
3094 case DataGridViewAutoSizeRowsMode.AllCells:
3095 mode = DataGridViewAutoSizeRowMode.AllCells;
3097 case DataGridViewAutoSizeRowsMode.DisplayedHeaders:
3098 mode = DataGridViewAutoSizeRowMode.RowHeader;
3099 displayed_only = true;
3101 case DataGridViewAutoSizeRowsMode.DisplayedCellsExceptHeaders:
3102 mode = DataGridViewAutoSizeRowMode.AllCellsExceptHeader;
3103 displayed_only = true;
3105 case DataGridViewAutoSizeRowsMode.DisplayedCells:
3106 mode = DataGridViewAutoSizeRowMode.AllCells;
3107 displayed_only = true;
3111 foreach (DataGridViewRow row in Rows) {
3112 if (!displayed_only || row.Displayed) {
3113 int new_height = row.GetPreferredHeight (row.Index, mode, fixedWidth);
3115 if (row.Height != new_height)
3116 row.SetAutoSizeHeight (new_height);
3121 [MonoTODO ("Does not use fixedMode parameter")]
3122 protected void AutoResizeRows (int rowIndexStart, int rowsCount, DataGridViewAutoSizeRowMode autoSizeRowMode, bool fixedWidth)
3124 for (int i = rowIndexStart; i < rowIndexStart + rowsCount; i++)
3125 AutoResizeRow (i, autoSizeRowMode, fixedWidth);
3128 protected void ClearSelection (int columnIndexException, int rowIndexException, bool selectExceptionElement) {
3129 if (columnIndexException >= columns.Count) {
3130 throw new ArgumentOutOfRangeException("ColumnIndexException is greater than the highest column index.");
3132 if (selectionMode == DataGridViewSelectionMode.FullRowSelect) {
3133 if (columnIndexException < -1) {
3134 throw new ArgumentOutOfRangeException("ColumnIndexException is less than -1.");
3138 if (columnIndexException < 0) {
3139 throw new ArgumentOutOfRangeException("ColumnIndexException is less than 0.");
3142 if (rowIndexException >= rows.Count) {
3143 throw new ArgumentOutOfRangeException("RowIndexException is greater than the highest row index.");
3145 if (selectionMode == DataGridViewSelectionMode.FullColumnSelect) {
3146 if (rowIndexException < -1) {
3147 throw new ArgumentOutOfRangeException("RowIndexException is less than -1.");
3151 if (rowIndexException < 0) {
3152 throw new ArgumentOutOfRangeException("RowIndexException is less than 0.");
3155 switch (selectionMode) {
3156 case DataGridViewSelectionMode.FullRowSelect:
3157 foreach (DataGridViewRow row in rows) {
3158 if (selectExceptionElement && row.Index == rowIndexException) {
3161 SetSelectedRowCore (row.Index, false);
3164 case DataGridViewSelectionMode.FullColumnSelect:
3165 foreach (DataGridViewColumn col in columns) {
3166 if (selectExceptionElement && col.Index == columnIndexException) {
3169 SetSelectedColumnCore (col.Index, false);
3173 foreach (DataGridViewCell cell in SelectedCells) {
3174 if (selectExceptionElement && cell.RowIndex == rowIndexException && cell.ColumnIndex == columnIndexException) {
3177 SetSelectedCellCore (cell.ColumnIndex, cell.RowIndex, false);
3183 protected override AccessibleObject CreateAccessibilityInstance ()
3185 return new DataGridViewAccessibleObject(this);
3188 [EditorBrowsable (EditorBrowsableState.Advanced)]
3189 protected virtual DataGridViewColumnCollection CreateColumnsInstance ()
3191 return new DataGridViewColumnCollection(this);
3194 protected override Control.ControlCollection CreateControlsInstance ()
3196 return new DataGridViewControlCollection (this);
3199 [EditorBrowsable (EditorBrowsableState.Advanced)]
3200 protected virtual DataGridViewRowCollection CreateRowsInstance ()
3202 return new DataGridViewRowCollection(this);
3205 protected override void Dispose (bool disposing) {
3208 protected override AccessibleObject GetAccessibilityObjectById (int objectId)
3210 throw new NotImplementedException();
3213 protected override bool IsInputChar (char charCode)
3218 protected override bool IsInputKey (Keys keyData)
3220 // Don't look at the modifiers
3221 keyData = keyData & ~Keys.Modifiers;
3243 protected virtual void OnAllowUserToAddRowsChanged (EventArgs e)
3245 EventHandler eh = (EventHandler)(Events [AllowUserToAddRowsChangedEvent]);
3250 protected virtual void OnAllowUserToDeleteRowsChanged (EventArgs e)
3252 EventHandler eh = (EventHandler)(Events [AllowUserToDeleteRowsChangedEvent]);
3257 protected virtual void OnAllowUserToOrderColumnsChanged (EventArgs e)
3259 EventHandler eh = (EventHandler)(Events [AllowUserToOrderColumnsChangedEvent]);
3264 protected virtual void OnAllowUserToResizeColumnsChanged (EventArgs e)
3266 EventHandler eh = (EventHandler)(Events [AllowUserToResizeColumnsChangedEvent]);
3271 protected virtual void OnAllowUserToResizeRowsChanged (EventArgs e)
3273 EventHandler eh = (EventHandler)(Events [AllowUserToResizeRowsChangedEvent]);
3278 protected virtual void OnAlternatingRowsDefaultCellStyleChanged (EventArgs e)
3280 EventHandler eh = (EventHandler)(Events [AlternatingRowsDefaultCellStyleChangedEvent]);
3285 protected virtual void OnAutoGenerateColumnsChanged (EventArgs e)
3287 EventHandler eh = (EventHandler)(Events [AutoGenerateColumnsChangedEvent]);
3292 protected internal virtual void OnAutoSizeColumnModeChanged (DataGridViewAutoSizeColumnModeEventArgs e)
3294 DataGridViewAutoSizeColumnModeEventHandler eh = (DataGridViewAutoSizeColumnModeEventHandler)(Events [AutoSizeColumnModeChangedEvent]);
3299 protected virtual void OnAutoSizeColumnsModeChanged (DataGridViewAutoSizeColumnsModeEventArgs e)
3301 DataGridViewAutoSizeColumnsModeEventHandler eh = (DataGridViewAutoSizeColumnsModeEventHandler)(Events [AutoSizeColumnsModeChangedEvent]);
3306 protected virtual void OnAutoSizeRowsModeChanged (DataGridViewAutoSizeModeEventArgs e)
3308 DataGridViewAutoSizeModeEventHandler eh = (DataGridViewAutoSizeModeEventHandler)(Events [AutoSizeRowsModeChangedEvent]);
3313 protected virtual void OnBackgroundColorChanged (EventArgs e)
3315 EventHandler eh = (EventHandler)(Events [BackgroundColorChangedEvent]);
3320 protected override void OnBindingContextChanged (EventArgs e)
3322 base.OnBindingContextChanged(e);
3325 protected virtual void OnBorderStyleChanged (EventArgs e)
3327 EventHandler eh = (EventHandler)(Events [BorderStyleChangedEvent]);
3332 protected virtual void OnCancelRowEdit (QuestionEventArgs e) {
3333 QuestionEventHandler eh = (QuestionEventHandler)(Events [CancelRowEditEvent]);
3338 protected virtual void OnCellBeginEdit (DataGridViewCellCancelEventArgs e)
3340 DataGridViewCellCancelEventHandler eh = (DataGridViewCellCancelEventHandler)(Events [CellBeginEditEvent]);
3345 protected virtual void OnCellBorderStyleChanged (EventArgs e)
3347 EventHandler eh = (EventHandler)(Events [CellBorderStyleChangedEvent]);
3352 protected virtual void OnCellClick (DataGridViewCellEventArgs e)
3354 DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3356 cell.OnClickInternal (e);
3358 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellClickEvent]);
3363 protected virtual void OnCellContentClick (DataGridViewCellEventArgs e)
3365 DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3367 cell.OnContentClickInternal (e);
3369 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellContentClickEvent]);
3374 protected virtual void OnCellContentDoubleClick (DataGridViewCellEventArgs e)
3376 DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3378 cell.OnContentDoubleClickInternal (e);
3380 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellContentDoubleClickEvent]);
3385 protected virtual void OnCellContextMenuStripChanged (DataGridViewCellEventArgs e)
3387 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellContextMenuStripChangedEvent]);
3392 protected virtual void OnCellContextMenuStripNeeded (DataGridViewCellContextMenuStripNeededEventArgs e)
3394 DataGridViewCellContextMenuStripNeededEventHandler eh = (DataGridViewCellContextMenuStripNeededEventHandler)(Events [CellContextMenuStripNeededEvent]);
3399 protected virtual void OnCellDoubleClick (DataGridViewCellEventArgs e)
3401 DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3403 cell.OnDoubleClickInternal (e);
3404 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellDoubleClickEvent]);
3409 protected virtual void OnCellEndEdit (DataGridViewCellEventArgs e)
3411 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellEndEditEvent]);
3416 protected virtual void OnCellEnter (DataGridViewCellEventArgs e)
3418 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellEnterEvent]);
3423 protected internal virtual void OnCellErrorTextChanged (DataGridViewCellEventArgs e)
3425 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellErrorTextChangedEvent]);
3430 protected virtual void OnCellErrorTextNeeded (DataGridViewCellErrorTextNeededEventArgs e)
3432 DataGridViewCellErrorTextNeededEventHandler eh = (DataGridViewCellErrorTextNeededEventHandler)(Events [CellErrorTextNeededEvent]);
3437 internal void OnCellFormattingInternal (DataGridViewCellFormattingEventArgs e)
3439 OnCellFormatting (e);
3442 protected virtual void OnCellFormatting (DataGridViewCellFormattingEventArgs e)
3444 DataGridViewCellFormattingEventHandler eh = (DataGridViewCellFormattingEventHandler)(Events [CellFormattingEvent]);
3449 protected virtual void OnCellLeave (DataGridViewCellEventArgs e)
3451 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellLeaveEvent]);
3456 protected virtual void OnCellMouseClick (DataGridViewCellMouseEventArgs e)
3458 DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3460 cell.OnMouseClickInternal (e);
3462 DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [CellMouseClickEvent]);
3467 protected virtual void OnCellMouseDoubleClick (DataGridViewCellMouseEventArgs e)
3469 DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3471 cell.OnMouseDoubleClickInternal (e);
3473 DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [CellMouseDoubleClickEvent]);
3478 protected virtual void OnCellMouseDown (DataGridViewCellMouseEventArgs e)
3481 DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3483 cell.OnMouseDownInternal (e);
3485 DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [CellMouseDownEvent]);
3490 protected virtual void OnCellMouseEnter (DataGridViewCellEventArgs e)
3492 DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3494 cell.OnMouseEnterInternal (e.RowIndex);
3496 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellMouseEnterEvent]);
3501 protected virtual void OnCellMouseLeave (DataGridViewCellEventArgs e)
3503 DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3505 cell.OnMouseLeaveInternal (e.RowIndex);
3507 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellMouseLeaveEvent]);
3512 protected virtual void OnCellMouseMove (DataGridViewCellMouseEventArgs e)
3514 DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3516 cell.OnMouseMoveInternal (e);
3518 DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [CellMouseMoveEvent]);
3523 protected virtual void OnCellMouseUp (DataGridViewCellMouseEventArgs e)
3525 DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3527 cell.OnMouseUpInternal (e);
3529 DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [CellMouseUpEvent]);
3534 internal void OnCellPaintingInternal (DataGridViewCellPaintingEventArgs e)
3539 protected virtual void OnCellPainting (DataGridViewCellPaintingEventArgs e)
3541 DataGridViewCellPaintingEventHandler eh = (DataGridViewCellPaintingEventHandler)(Events [CellPaintingEvent]);
3546 protected internal virtual void OnCellParsing (DataGridViewCellParsingEventArgs e)
3548 DataGridViewCellParsingEventHandler eh = (DataGridViewCellParsingEventHandler)(Events [CellParsingEvent]);
3553 internal void OnCellStateChangedInternal (DataGridViewCellStateChangedEventArgs e) {
3554 this.OnCellStateChanged (e);
3557 protected virtual void OnCellStateChanged (DataGridViewCellStateChangedEventArgs e)
3559 DataGridViewCellStateChangedEventHandler eh = (DataGridViewCellStateChangedEventHandler)(Events [CellStateChangedEvent]);
3564 protected virtual void OnCellStyleChanged (DataGridViewCellEventArgs e)
3566 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellStyleChangedEvent]);
3571 protected virtual void OnCellStyleContentChanged (DataGridViewCellStyleContentChangedEventArgs e) {
3572 DataGridViewCellStyleContentChangedEventHandler eh = (DataGridViewCellStyleContentChangedEventHandler)(Events [CellStyleContentChangedEvent]);
3577 protected virtual void OnCellToolTipTextChanged (DataGridViewCellEventArgs e) {
3578 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellToolTipTextChangedEvent]);
3583 protected virtual void OnCellToolTipTextNeeded (DataGridViewCellToolTipTextNeededEventArgs e)
3585 DataGridViewCellToolTipTextNeededEventHandler eh = (DataGridViewCellToolTipTextNeededEventHandler)(Events [CellToolTipTextNeededEvent]);
3590 protected virtual void OnCellValidated (DataGridViewCellEventArgs e)
3592 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellValidatedEvent]);
3597 protected virtual void OnCellValidating (DataGridViewCellValidatingEventArgs e)
3599 DataGridViewCellValidatingEventHandler eh = (DataGridViewCellValidatingEventHandler)(Events [CellValidatingEvent]);
3604 protected virtual void OnCellValueChanged (DataGridViewCellEventArgs e)
3606 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellValueChangedEvent]);
3611 protected internal virtual void OnCellValueNeeded (DataGridViewCellValueEventArgs e)
3613 DataGridViewCellValueEventHandler eh = (DataGridViewCellValueEventHandler)(Events [CellValueNeededEvent]);
3618 protected virtual void OnCellValuePushed (DataGridViewCellValueEventArgs e)
3620 DataGridViewCellValueEventHandler eh = (DataGridViewCellValueEventHandler)(Events [CellValuePushedEvent]);
3625 internal void OnColumnAddedInternal (DataGridViewColumnEventArgs e)
3627 if (e.Column.CellTemplate != null) {
3628 foreach (DataGridViewRow row in Rows)
3629 row.Cells.Add ((DataGridViewCell)e.Column.CellTemplate.Clone ());
3632 AutoResizeColumnsInternal ();
3634 PrepareEditingRow (false, true);
3637 protected virtual void OnColumnAdded (DataGridViewColumnEventArgs e)
3639 DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnAddedEvent]);
3644 protected internal virtual void OnColumnContextMenuStripChanged (DataGridViewColumnEventArgs e)
3646 DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnContextMenuStripChangedEvent]);
3651 protected internal virtual void OnColumnDataPropertyNameChanged (DataGridViewColumnEventArgs e)
3653 DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnDataPropertyNameChangedEvent]);
3658 protected internal virtual void OnColumnDefaultCellStyleChanged (DataGridViewColumnEventArgs e)
3660 DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnDefaultCellStyleChangedEvent]);
3665 protected internal virtual void OnColumnDisplayIndexChanged (DataGridViewColumnEventArgs e)
3667 DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnDisplayIndexChangedEvent]);
3672 protected virtual void OnColumnDividerDoubleClick (DataGridViewColumnDividerDoubleClickEventArgs e)
3674 DataGridViewColumnDividerDoubleClickEventHandler eh = (DataGridViewColumnDividerDoubleClickEventHandler)(Events [ColumnDividerDoubleClickEvent]);
3679 protected internal virtual void OnColumnDividerWidthChanged (DataGridViewColumnEventArgs e)
3681 DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnDividerWidthChangedEvent]);
3686 protected internal virtual void OnColumnHeaderCellChanged (DataGridViewColumnEventArgs e)
3688 DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnHeaderCellChangedEvent]);
3693 protected virtual void OnColumnHeaderMouseClick (DataGridViewCellMouseEventArgs e)
3695 DataGridViewColumn col = Columns[e.ColumnIndex];
3697 if (col.SortMode == DataGridViewColumnSortMode.Automatic) {
3698 ListSortDirection new_order;
3700 // Always use ascending unless we are clicking on a
3701 // column that is already sorted ascending.
3702 if (SortedColumn != col || sortOrder != SortOrder.Ascending)
3703 new_order = ListSortDirection.Ascending;
3705 new_order = ListSortDirection.Descending;
3707 Sort (col, new_order);
3710 DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [ColumnHeaderMouseClickEvent]);
3715 protected virtual void OnColumnHeaderMouseDoubleClick (DataGridViewCellMouseEventArgs e)
3717 DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [ColumnHeaderMouseDoubleClickEvent]);
3722 protected virtual void OnColumnHeadersBorderStyleChanged (EventArgs e)
3724 EventHandler eh = (EventHandler)(Events [ColumnHeadersBorderStyleChangedEvent]);
3729 protected virtual void OnColumnHeadersDefaultCellStyleChanged (EventArgs e)
3731 EventHandler eh = (EventHandler)(Events [ColumnHeadersDefaultCellStyleChangedEvent]);
3736 protected virtual void OnColumnHeadersHeightChanged (EventArgs e)
3738 EventHandler eh = (EventHandler)(Events [ColumnHeadersHeightChangedEvent]);
3743 protected virtual void OnColumnHeadersHeightSizeModeChanged (DataGridViewAutoSizeModeEventArgs e)
3745 DataGridViewAutoSizeModeEventHandler eh = (DataGridViewAutoSizeModeEventHandler)(Events [ColumnHeadersHeightSizeModeChangedEvent]);
3750 protected internal virtual void OnColumnMinimumWidthChanged (DataGridViewColumnEventArgs e)
3752 DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnMinimumWidthChangedEvent]);
3757 protected internal virtual void OnColumnNameChanged (DataGridViewColumnEventArgs e)
3759 DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnNameChangedEvent]);
3764 internal void OnColumnRemovedInternal (DataGridViewColumnEventArgs e)
3766 if (e.Column.CellTemplate != null) {
3767 int index = e.Column.Index;
3769 foreach (DataGridViewRow row in Rows)
3770 row.Cells.RemoveAt (index);
3773 AutoResizeColumnsInternal ();
3774 OnColumnRemoved (e);
3775 PrepareEditingRow (false, true);
3778 protected virtual void OnColumnRemoved (DataGridViewColumnEventArgs e)
3780 DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnRemovedEvent]);
3785 protected internal virtual void OnColumnSortModeChanged (DataGridViewColumnEventArgs e)
3787 DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnSortModeChangedEvent]);
3792 protected internal virtual void OnColumnStateChanged (DataGridViewColumnStateChangedEventArgs e)
3794 DataGridViewColumnStateChangedEventHandler eh = (DataGridViewColumnStateChangedEventHandler)(Events [ColumnStateChangedEvent]);
3799 protected internal virtual void OnColumnToolTipTextChanged (DataGridViewColumnEventArgs e)
3801 DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnToolTipTextChangedEvent]);
3806 protected internal virtual void OnColumnWidthChanged (DataGridViewColumnEventArgs e)
3808 DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnWidthChangedEvent]);
3813 protected virtual void OnCurrentCellChanged (EventArgs e)
3815 EventHandler eh = (EventHandler)(Events [CurrentCellChangedEvent]);
3820 protected virtual void OnCurrentCellDirtyStateChanged (EventArgs e)
3822 EventHandler eh = (EventHandler)(Events [CurrentCellDirtyStateChangedEvent]);
3827 protected override void OnCursorChanged (EventArgs e)
3829 base.OnCursorChanged (e);
3832 protected virtual void OnDataBindingComplete (DataGridViewBindingCompleteEventArgs e)
3834 DataGridViewBindingCompleteEventHandler eh = (DataGridViewBindingCompleteEventHandler)(Events [DataBindingCompleteEvent]);
3839 protected virtual void OnDataError (bool displayErrorDialogIfNoHandler, DataGridViewDataErrorEventArgs e)
3841 DataGridViewDataErrorEventHandler eh = (DataGridViewDataErrorEventHandler)(Events [DataErrorEvent]);
3845 else if (displayErrorDialogIfNoHandler)
3846 MessageBox.Show (e.ToString ());
3848 protected virtual void OnDataMemberChanged (EventArgs e) {
3849 EventHandler eh = (EventHandler)(Events [DataMemberChangedEvent]);
3854 protected virtual void OnDataSourceChanged (EventArgs e) {
3855 EventHandler eh = (EventHandler)(Events [DataSourceChangedEvent]);
3860 protected virtual void OnDefaultCellStyleChanged (EventArgs e) {
3861 EventHandler eh = (EventHandler)(Events [DefaultCellStyleChangedEvent]);
3866 protected virtual void OnDefaultValuesNeeded (DataGridViewRowEventArgs e) {
3867 DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [DefaultValuesNeededEvent]);
3872 protected override void OnDoubleClick (EventArgs e) {
3873 base.OnDoubleClick(e);
3876 protected virtual void OnEditingControlShowing (DataGridViewEditingControlShowingEventArgs e) {
3877 DataGridViewEditingControlShowingEventHandler eh = (DataGridViewEditingControlShowingEventHandler)(Events [EditingControlShowingEvent]);
3882 protected virtual void OnEditModeChanged (EventArgs e)
3884 EventHandler eh = (EventHandler)(Events [EditModeChangedEvent]);
3889 protected override void OnEnabledChanged (EventArgs e)
3891 base.OnEnabledChanged(e);
3894 protected override void OnEnter (EventArgs e )
3899 protected override void OnGotFocus(EventArgs e)
3901 base.OnGotFocus (e);
3903 // To add focus rectangle if needed
3904 if (currentCell != null && ShowFocusCues)
3905 InvalidateCell (currentCell);
3908 protected override void OnFontChanged (EventArgs e)
3910 base.OnFontChanged(e);
3913 protected override void OnForeColorChanged (EventArgs e)
3915 base.OnForeColorChanged(e);
3918 protected virtual void OnGridColorChanged (EventArgs e)
3920 EventHandler eh = (EventHandler)(Events [GridColorChangedEvent]);
3925 protected override void OnHandleCreated (EventArgs e)
3927 base.OnHandleCreated(e);
3929 if (CurrentCell == null && Rows.Count > 0 && Columns.Count > 0)
3930 MoveCurrentCell (ColumnDisplayIndexToIndex (0), 0, true, false, false, false);
3933 protected override void OnHandleDestroyed(EventArgs e)
3935 base.OnHandleDestroyed (e);
3938 [EditorBrowsable (EditorBrowsableState.Advanced)]
3939 protected override void OnKeyDown (KeyEventArgs e)
3943 e.Handled = ProcessDataGridViewKey (e);
3946 [EditorBrowsable (EditorBrowsableState.Advanced)]
3947 protected override void OnKeyPress (KeyPressEventArgs e)
3952 [EditorBrowsable (EditorBrowsableState.Advanced)]
3953 protected override void OnKeyUp (KeyEventArgs e)
3958 protected override void OnLayout (LayoutEventArgs e)
3960 if (horizontalScrollBar.Visible && verticalScrollBar.Visible) {
3961 horizontalScrollBar.Bounds = new Rectangle (BorderWidth, Height - BorderWidth - horizontalScrollBar.Height, Width - (2 * BorderWidth) - verticalScrollBar.Width, horizontalScrollBar.Height);
3962 verticalScrollBar.Bounds = new Rectangle (Width - BorderWidth - verticalScrollBar.Width, BorderWidth, verticalScrollBar.Width, Height - (2 * BorderWidth) - horizontalScrollBar.Height);
3963 } else if (horizontalScrollBar.Visible)
3964 horizontalScrollBar.Bounds = new Rectangle (BorderWidth, Height - BorderWidth - horizontalScrollBar.Height, Width - (2 * BorderWidth), horizontalScrollBar.Height);
3965 else if (verticalScrollBar.Visible)
3966 verticalScrollBar.Bounds = new Rectangle (Width - BorderWidth - verticalScrollBar.Width, BorderWidth, verticalScrollBar.Width, Height - (2 * BorderWidth));
3968 AutoResizeColumnsInternal ();
3972 protected override void OnLeave (EventArgs e)
3977 protected override void OnLostFocus(EventArgs e)
3979 base.OnLostFocus (e);
3981 // To remove focus rectangle if needed
3982 if (currentCell != null && ShowFocusCues)
3983 InvalidateCell (currentCell);
3986 protected override void OnMouseClick (MouseEventArgs e)
3988 base.OnMouseClick(e);
3990 if (column_resize_active || row_resize_active)
3993 //Console.WriteLine("Mouse: Clicks: {0}; Delta: {1}; X: {2}; Y: {3};", e.Clicks, e.Delta, e.X, e.Y);
3994 HitTestInfo hit = HitTest (e.X, e.Y);
3997 case DataGridViewHitTestType.Cell:
3998 Rectangle display = GetCellDisplayRectangle (hit.ColumnIndex, hit.RowIndex, false);
3999 Point cellpoint = new Point (e.X - display.X, e.Y - display.Y);
4001 OnCellMouseClick (new DataGridViewCellMouseEventArgs (hit.ColumnIndex, hit.RowIndex, cellpoint.X, cellpoint.Y, e));
4003 DataGridViewCell cell = GetCellInternal (hit.ColumnIndex, hit.RowIndex);
4005 if (cell.GetContentBounds (hit.RowIndex).Contains (cellpoint)) {
4006 DataGridViewCellEventArgs dgvcea = new DataGridViewCellEventArgs (hit.ColumnIndex, hit.RowIndex);
4007 OnCellContentClick (dgvcea);
4011 case DataGridViewHitTestType.ColumnHeader:
4012 Rectangle display2 = GetCellDisplayRectangle (hit.ColumnIndex, hit.RowIndex, false);
4013 Point cellpoint2 = new Point (e.X - display2.X, e.Y - display2.Y);
4015 OnColumnHeaderMouseClick (new DataGridViewCellMouseEventArgs (hit.ColumnIndex, hit.RowIndex, cellpoint2.X, cellpoint2.Y, e));
4020 protected override void OnMouseDoubleClick (MouseEventArgs e)
4022 base.OnMouseDoubleClick(e);
4025 private void DoSelectionOnMouseDown (HitTestInfo hitTest)
4027 Keys modifiers = Control.ModifierKeys;
4028 bool isControl = (modifiers & Keys.Control) != 0;
4029 bool isShift = (modifiers & Keys.Shift) != 0;
4030 //bool isRowHeader = hitTest.Type == DataGridViewHitTestType.RowHeader;
4031 //bool isColHeader = hitTest.Type == DataGridViewHitTestType.ColumnHeader;
4032 DataGridViewSelectionMode mode;
4034 switch (hitTest.Type) {
4035 case DataGridViewHitTestType.Cell:
4036 mode = selectionMode;
4038 case DataGridViewHitTestType.ColumnHeader:
4039 mode = selectionMode == DataGridViewSelectionMode.ColumnHeaderSelect ? DataGridViewSelectionMode.FullColumnSelect : selectionMode;
4041 if (mode != DataGridViewSelectionMode.FullColumnSelect)
4044 case DataGridViewHitTestType.RowHeader:
4045 mode = selectionMode == DataGridViewSelectionMode.RowHeaderSelect ? DataGridViewSelectionMode.FullRowSelect : selectionMode;
4047 if (mode != DataGridViewSelectionMode.FullRowSelect)
4049 break; // Handled below
4055 // If SHIFT is pressed:
4056 // Select all from selected_row/column/cell to current row/column/cell, unselect everything else
4058 // Unselect all rows/columns/cells, select the clicked one
4059 int min_row, max_row;
4060 int min_col, max_col;
4062 selected_row = hitTest.RowIndex;
4063 selected_column = hitTest.ColumnIndex;
4066 if (selected_row != -1)
4067 selected_row = hitTest.RowIndex;
4068 if (selected_column != -1)
4069 selected_column = hitTest.ColumnIndex;
4071 if (selected_row >= hitTest.RowIndex) {
4072 min_row = hitTest.RowIndex;
4073 max_row = isShift ? selected_row : min_row;
4075 max_row = hitTest.RowIndex;
4076 min_row = isShift ? selected_row : max_row;
4078 if (selected_column >= hitTest.ColumnIndex) {
4079 min_col = hitTest.ColumnIndex;
4080 max_col = isShift ? selected_column : min_col;
4082 max_col = hitTest.ColumnIndex;
4083 min_col = isShift ? selected_column : max_col;
4087 case DataGridViewSelectionMode.FullRowSelect:
4088 for (int i = 0; i < RowCount; i++) {
4089 bool select = i >= min_row && i <= max_row;
4091 for (int c = 0; c < ColumnCount; c++) {
4092 if (Rows [i].Cells [c].Selected) {
4093 SetSelectedCellCore (c, i, false);
4097 if (select != Rows [i].Selected) {
4098 SetSelectedRowCore (i, select);
4102 case DataGridViewSelectionMode.FullColumnSelect:
4103 for (int i = 0; i < ColumnCount; i++) {
4104 bool select = i >= min_col && i <= max_col;
4106 for (int r = 0; r < RowCount; r++) {
4107 if (Rows [r].Cells [i].Selected) {
4108 SetSelectedCellCore (i, r, false);
4112 if (select != Columns [i].Selected) {
4113 SetSelectedColumnCore (i, select);
4117 case DataGridViewSelectionMode.ColumnHeaderSelect:
4118 case DataGridViewSelectionMode.RowHeaderSelect:
4120 case DataGridViewSelectionMode.CellSelect:
4122 for (int c = 0; c < ColumnCount; c++) {
4123 if (columns [c].Selected)
4124 SetSelectedColumnCore (c, false);
4127 for (int r = 0; r < RowCount; r++) {
4128 if (rows [r].Selected)
4129 SetSelectedRowCore (r, false);
4132 for (int r = 0; r < RowCount; r++) {
4133 for (int c = 0; c < ColumnCount; c++) {
4134 bool select = (r >= min_row && r <= max_row) && (c >= min_col && c <= max_col);
4135 if (select != Rows [r].Cells [c].Selected)
4136 SetSelectedCellCore (c, r, select);
4142 } else if (isControl) {
4143 // Switch the selected state of the row.
4145 case DataGridViewSelectionMode.FullRowSelect:
4146 SetSelectedRowCore (hitTest.RowIndex, !rows [hitTest.RowIndex].Selected);
4148 case DataGridViewSelectionMode.FullColumnSelect:
4149 SetSelectedColumnCore (hitTest.ColumnIndex, !columns [hitTest.ColumnIndex].Selected);
4151 case DataGridViewSelectionMode.ColumnHeaderSelect:
4152 case DataGridViewSelectionMode.RowHeaderSelect:
4154 case DataGridViewSelectionMode.CellSelect:
4155 if (hitTest.ColumnIndex >= 0 && hitTest.RowIndex >= 0) {
4156 SetSelectedCellCore (hitTest.ColumnIndex, hitTest.RowIndex, !Rows [hitTest.RowIndex].Cells [hitTest.ColumnIndex].Selected);
4164 protected override void OnMouseDown (MouseEventArgs e)
4166 base.OnMouseDown(e);
4168 HitTestInfo hitTest = HitTest(e.X, e.Y);
4170 DataGridViewCell cell = null;
4171 DataGridViewRow row = null;
4172 Rectangle cellBounds;
4174 if (hitTest.Type == DataGridViewHitTestType.ColumnHeader && MouseOverColumnResize (hitTest.ColumnIndex, e.X)) {
4175 if (e.Clicks == 2) {
4177 AutoResizeColumn (hitTest.ColumnIndex);
4181 resize_band = hitTest.ColumnIndex;
4182 column_resize_active = true;
4183 resize_band_start = e.X;
4184 resize_band_delta = 0;
4186 DrawVerticalResizeLine (resize_band_start);
4190 if (hitTest.Type == DataGridViewHitTestType.RowHeader && MouseOverRowResize (hitTest.RowIndex, e.Y)) {
4191 if (e.Clicks == 2) {
4193 AutoResizeRow (hitTest.RowIndex);
4197 resize_band = hitTest.RowIndex;
4198 row_resize_active = true;
4199 resize_band_start = e.Y;
4200 resize_band_delta = 0;
4202 DrawHorizontalResizeLine (resize_band_start);
4206 if (hitTest.Type == DataGridViewHitTestType.Cell) {
4207 row = rows [hitTest.RowIndex];
4208 cell = row.Cells [hitTest.ColumnIndex];
4209 SetCurrentCellAddressCore (cell.ColumnIndex, cell.RowIndex, false, true, true);
4210 cellBounds = GetCellDisplayRectangle (hitTest.ColumnIndex, hitTest.RowIndex, false);
4211 OnCellMouseDown (new DataGridViewCellMouseEventArgs (hitTest.ColumnIndex, hitTest.RowIndex, e.X - cellBounds.X, e.Y - cellBounds.Y, e));
4212 OnCellClick (new DataGridViewCellEventArgs (hitTest.ColumnIndex, hitTest.RowIndex));
4215 DoSelectionOnMouseDown (hitTest);
4217 if (hitTest.Type != DataGridViewHitTestType.Cell) {
4218 if (hitTest.Type == DataGridViewHitTestType.ColumnHeader)
4219 pressed_header_cell = columns [hitTest.ColumnIndex].HeaderCell;
4220 else if (hitTest.Type == DataGridViewHitTestType.RowHeader)
4221 pressed_header_cell = rows [hitTest.RowIndex].HeaderCell;
4230 private void UpdateBindingPosition (int position)
4232 BindingSource source = dataSource as BindingSource;
4233 if (source != null && source.CurrencyManager != null)
4234 source.CurrencyManager.Position = position;
4237 protected override void OnMouseEnter (EventArgs e)
4239 base.OnMouseEnter(e);
4242 protected override void OnMouseLeave (EventArgs e)
4244 base.OnMouseLeave (e);
4246 if (hover_cell != null) {
4247 OnCellMouseLeave (new DataGridViewCellEventArgs (hover_cell.ColumnIndex, hover_cell.RowIndex));
4251 EnteredHeaderCell = null;
4254 protected override void OnMouseMove (MouseEventArgs e)
4256 base.OnMouseMove (e);
4258 if (column_resize_active) {
4259 // Erase the old line
4260 DrawVerticalResizeLine (resize_band_start + resize_band_delta);
4262 resize_band_delta = e.X - resize_band_start;
4264 // Draw the new line
4265 DrawVerticalResizeLine (resize_band_start + resize_band_delta);
4269 if (row_resize_active) {
4270 // Erase the old line
4271 DrawHorizontalResizeLine (resize_band_start + resize_band_delta);
4273 resize_band_delta = e.Y - resize_band_start;
4275 // Draw the new line
4276 DrawHorizontalResizeLine (resize_band_start + resize_band_delta);
4280 Cursor new_cursor = Cursors.Default;
4281 HitTestInfo hit = this.HitTest (e.X, e.Y);
4283 if (hit.Type == DataGridViewHitTestType.Cell) {
4284 EnteredHeaderCell = null;
4286 DataGridViewCell new_cell = GetCellInternal (hit.ColumnIndex, hit.RowIndex);
4288 // Check if we have moved into an error icon area
4289 Rectangle icon = new_cell.ErrorIconBounds;
4291 if (!icon.IsEmpty) {
4292 Point loc = GetCellDisplayRectangle (hit.ColumnIndex, hit.RowIndex, false).Location;
4297 if (icon.Contains (e.X, e.Y)) {
4298 if (tooltip_currently_showing != new_cell)
4299 MouseEnteredErrorIcon (new_cell);
4301 MouseLeftErrorIcon (new_cell);
4304 // We have never been in a cell before
4305 if (hover_cell == null) {
4306 hover_cell = new_cell;
4307 OnCellMouseEnter (new DataGridViewCellEventArgs (hit.ColumnIndex, hit.RowIndex));
4309 Rectangle display = GetCellDisplayRectangle (hit.ColumnIndex, hit.RowIndex, false);
4310 OnCellMouseMove (new DataGridViewCellMouseEventArgs (hit.ColumnIndex, hit.RowIndex, e.X - display.X, e.Y - display.Y, e));
4315 // Were we already in this cell?
4316 if (hover_cell.RowIndex == hit.RowIndex && hover_cell.ColumnIndex == hit.ColumnIndex) {
4317 Rectangle display = GetCellDisplayRectangle (hit.ColumnIndex, hit.RowIndex, false);
4318 OnCellMouseMove (new DataGridViewCellMouseEventArgs (hit.ColumnIndex, hit.RowIndex, e.X - display.X, e.Y - display.Y, e));
4323 // We are changing cells
4324 OnCellMouseLeave (new DataGridViewCellEventArgs (hover_cell.ColumnIndex, hover_cell.RowIndex));
4326 hover_cell = new_cell;
4328 OnCellMouseEnter (new DataGridViewCellEventArgs (hit.ColumnIndex, hit.RowIndex));
4330 Rectangle display2 = GetCellDisplayRectangle (hit.ColumnIndex, hit.RowIndex, false);
4331 OnCellMouseMove (new DataGridViewCellMouseEventArgs (hit.ColumnIndex, hit.RowIndex, e.X - display2.X, e.Y - display2.Y, e));
4334 } else if (hit.Type == DataGridViewHitTestType.RowHeader) {
4335 DataGridViewRowHeaderCell new_cell = Rows[hit.RowIndex].HeaderCell;
4337 EnteredHeaderCell = new_cell;
4339 if (MouseOverRowResize (hit.RowIndex, e.Y))
4340 new_cursor = Cursors.HSplit;
4342 // Check if we have moved into an error icon area
4343 Rectangle icon = new_cell.InternalErrorIconsBounds;
4345 if (!icon.IsEmpty) {
4346 Point loc = GetCellDisplayRectangle (0, hit.RowIndex, false).Location;
4348 icon.X += BorderWidth;
4351 if (icon.Contains (e.X, e.Y)) {
4352 if (tooltip_currently_showing != new_cell)
4353 MouseEnteredErrorIcon (new_cell);
4355 MouseLeftErrorIcon (new_cell);
4357 } else if (hit.Type == DataGridViewHitTestType.TopLeftHeader) {
4358 EnteredHeaderCell = null;
4360 DataGridViewTopLeftHeaderCell new_cell = (DataGridViewTopLeftHeaderCell)TopLeftHeaderCell;
4362 // Check if we have moved into an error icon area
4363 Rectangle icon = new_cell.InternalErrorIconsBounds;
4365 if (!icon.IsEmpty) {
4366 Point loc = Point.Empty;
4368 icon.X += BorderWidth;
4371 if (icon.Contains (e.X, e.Y)) {
4372 if (tooltip_currently_showing != new_cell)
4373 MouseEnteredErrorIcon (new_cell);
4375 MouseLeftErrorIcon (new_cell);
4379 if (hit.Type == DataGridViewHitTestType.ColumnHeader) {
4380 EnteredHeaderCell = Columns [hit.ColumnIndex].HeaderCell;
4382 if (MouseOverColumnResize (hit.ColumnIndex, e.X))
4383 new_cursor = Cursors.VSplit;
4385 EnteredHeaderCell = null;
4387 // We have left the cell area
4388 if (hover_cell != null) {
4389 OnCellMouseLeave (new DataGridViewCellEventArgs (hover_cell.ColumnIndex, hover_cell.RowIndex));
4394 Cursor = new_cursor;
4397 protected override void OnMouseUp (MouseEventArgs e)
4401 if (column_resize_active) {
4402 column_resize_active = false;
4404 if (resize_band_delta + Columns[resize_band].Width < 0)
4405 resize_band_delta = -Columns[resize_band].Width;
4407 Columns[resize_band].Width = Math.Max (resize_band_delta + Columns[resize_band].Width, Columns[resize_band].MinimumWidth);
4412 if (row_resize_active) {
4413 row_resize_active = false;
4415 if (resize_band_delta + Rows[resize_band].Height < 0)
4416 resize_band_delta = -Rows[resize_band].Height;
4418 Rows[resize_band].Height = Math.Max (resize_band_delta + Rows[resize_band].Height, Rows[resize_band].MinimumHeight);
4423 HitTestInfo hit = this.HitTest (e.X, e.Y);
4425 if (hit.Type == DataGridViewHitTestType.Cell) {
4426 Rectangle display = GetCellDisplayRectangle (hit.ColumnIndex, hit.RowIndex, false);
4427 OnCellMouseUp (new DataGridViewCellMouseEventArgs (hit.ColumnIndex, hit.RowIndex, e.X - display.X, e.Y - display.Y, e));
4430 if (pressed_header_cell != null) {
4431 DataGridViewHeaderCell cell = pressed_header_cell;
4432 pressed_header_cell = null;
4433 if (ThemeEngine.Current.DataGridViewHeaderCellHasPressedStyle (this))
4434 Invalidate (GetHeaderCellBounds (cell));
4438 protected override void OnMouseWheel (MouseEventArgs e)
4440 base.OnMouseWheel(e);
4443 protected virtual void OnMultiSelectChanged (EventArgs e)
4445 EventHandler eh = (EventHandler)(Events [MultiSelectChangedEvent]);
4446 if (eh != null) eh (this, e);
4449 protected virtual void OnNewRowNeeded (DataGridViewRowEventArgs e) {
4450 DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [NewRowNeededEvent]);
4451 if (eh != null) eh (this, e);
4454 int first_row_index = 0;
4455 internal int first_col_index = 0;
4457 protected override void OnPaint (PaintEventArgs e)
4461 Graphics g = e.Graphics;
4462 Rectangle bounds = ClientRectangle;
4464 // Paint the background
4465 PaintBackground (g, e.ClipRectangle, bounds);
4467 List<DataGridViewColumn> sortedColumns = columns.ColumnDisplayIndexSortedArrayList;
4469 // Take borders into account
4470 bounds.Inflate (-BorderWidth, -BorderWidth);
4472 // Paint the top left cell
4473 if (rowHeadersVisible && columnHeadersVisible && ColumnCount > 0) {
4474 Rectangle topleftbounds = new Rectangle (bounds.X, bounds.Y, rowHeadersWidth, columnHeadersHeight);
4476 TopLeftHeaderCell.PaintWork (g, e.ClipRectangle, topleftbounds, -1, TopLeftHeaderCell.State, ColumnHeadersDefaultCellStyle, AdvancedColumnHeadersBorderStyle, DataGridViewPaintParts.All);
4479 // Paint the column headers
4480 if (columnHeadersVisible) {
4481 Rectangle headerBounds = bounds;
4482 headerBounds.Height = columnHeadersHeight;
4484 if (rowHeadersVisible)
4485 headerBounds.X += rowHeadersWidth;
4487 for (int index = first_col_index; index < sortedColumns.Count; index++) {
4488 DataGridViewColumn col = sortedColumns[index];
4493 headerBounds.Width = col.Width;
4494 DataGridViewCell cell = col.HeaderCell;
4496 DataGridViewAdvancedBorderStyle intermediateBorderStyle = (DataGridViewAdvancedBorderStyle)((ICloneable)this.AdvancedColumnHeadersBorderStyle).Clone ();
4497 DataGridViewAdvancedBorderStyle borderStyle = AdjustColumnHeaderBorderStyle (this.AdvancedColumnHeadersBorderStyle, intermediateBorderStyle, cell.ColumnIndex == 0, cell.ColumnIndex == columns.Count - 1);
4499 cell.PaintWork (g, e.ClipRectangle, headerBounds, -1, cell.State, cell.InheritedStyle, borderStyle, DataGridViewPaintParts.All);
4501 headerBounds.X += col.Width;
4504 bounds.Y += columnHeadersHeight;
4507 gridWidth = rowHeadersVisible ? rowHeadersWidth : 0;
4510 int first_row_height = Rows.Count > 0 ? Rows[Math.Min (Rows.Count - 1, first_row_index)].Height : 0;
4511 // int room_left = this.Height;
4513 // Reset all columns to !Displayed
4514 for (int i = 0; i < Columns.Count; i++)
4515 Columns[i].DisplayedInternal = false;
4517 // Set Displayed columns
4518 for (int i = first_col_index; i < Columns.Count; i++) {
4519 DataGridViewColumn col = Columns.ColumnDisplayIndexSortedArrayList[i];
4524 col.DisplayedInternal = true;
4525 gridWidth += col.Width;
4527 if (gridWidth >= Width)
4531 // Reset all rows to !Displayed
4532 for (int i = 0; i < Rows.Count; i++)
4533 GetRowInternal (i).DisplayedInternal = false;
4536 for (int index = first_row_index; index < Rows.Count; index++) {
4537 DataGridViewRow row = Rows[index];
4538 GetRowInternal (index).DisplayedInternal = true;
4540 bounds.Height = row.Height;
4541 bool is_first = row.Index == 0;
4542 bool is_last = row.Index == rows.Count - 1;
4544 row.Paint (g, e.ClipRectangle, bounds, row.Index, row.GetState (row.Index), is_first, is_last);
4546 bounds.Y += bounds.Height;
4547 bounds.X = BorderWidth;
4549 if (bounds.Y >= ClientSize.Height - (horizontalScrollBar.Visible ? horizontalScrollBar.Height : 0))
4552 gridHeight += row.Height;
4557 foreach (DataGridViewColumn col in sortedColumns)
4559 gridWidth += col.Width;
4563 foreach (DataGridViewRow row in Rows)
4564 gridHeight += row.Height;
4566 if (rowHeadersVisible)
4567 gridWidth += rowHeadersWidth;
4569 if (columnHeadersVisible)
4570 gridHeight += columnHeadersHeight;
4572 bool horizontalVisible = false;
4573 bool verticalVisible = false;
4576 if (gridWidth > Size.Width || gridHeight > Size.Height) {
4577 Size = new Size(gridWidth, gridHeight);
4581 if (gridWidth > Size.Width) {
4582 horizontalVisible = true;
4584 if (gridHeight > Size.Height) {
4585 verticalVisible = true;
4587 if (horizontalScrollBar.Visible && (gridHeight + horizontalScrollBar.Height) > Size.Height) {
4588 verticalVisible = true;
4590 if (verticalScrollBar.Visible && (gridWidth + verticalScrollBar.Width) > Size.Width) {
4591 horizontalVisible = true;
4593 if (horizontalVisible) {
4594 horizontalScrollBar.Minimum = 0;
4595 horizontalScrollBar.Maximum = gridWidth;
4596 horizontalScrollBar.SmallChange = Columns[first_col_index].Width;
4597 horizontalScrollBar.LargeChange = ClientSize.Width - rowHeadersWidth;
4599 if (verticalVisible) {
4600 verticalScrollBar.Minimum = 0;
4601 verticalScrollBar.Maximum = gridHeight;
4602 verticalScrollBar.SmallChange = first_row_height + 1;
4603 verticalScrollBar.LargeChange = ClientSize.Height - columnHeadersHeight;
4607 horizontalScrollBar.Visible = horizontalVisible;
4608 verticalScrollBar.Visible = verticalVisible;
4610 // Paint the bottom right square if both scrollbars are displayed
4611 if (horizontalScrollBar.Visible && verticalScrollBar.Visible)
4612 g.FillRectangle (SystemBrushes.Control, new Rectangle (horizontalScrollBar.Right, verticalScrollBar.Bottom, verticalScrollBar.Width, horizontalScrollBar.Height));
4615 bounds = ClientRectangle;
4617 switch (BorderStyle) {
4618 case BorderStyle.FixedSingle:
4619 g.DrawRectangle (Pens.Black, new Rectangle (bounds.Left, bounds.Top, bounds.Width - 1, bounds.Height - 1));
4621 case BorderStyle.Fixed3D:
4622 ControlPaint.DrawBorder3D (g, bounds, Border3DStyle.Sunken);
4627 protected virtual void OnReadOnlyChanged (EventArgs e) {
4628 EventHandler eh = (EventHandler)(Events [ReadOnlyChangedEvent]);
4633 protected override void OnResize (EventArgs e) {
4635 AutoResizeColumnsInternal ();
4637 OnVScrollBarScroll (this, new ScrollEventArgs (ScrollEventType.ThumbPosition, verticalScrollBar.Value));
4638 OnHScrollBarScroll (this, new ScrollEventArgs (ScrollEventType.ThumbPosition, horizontalScrollBar.Value));
4641 protected override void OnRightToLeftChanged (EventArgs e) {
4642 base.OnRightToLeftChanged(e);
4645 // In MSDN2 documentation there's no internal here
4646 protected internal virtual void OnRowContextMenuStripChanged (DataGridViewRowEventArgs e)
4648 DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowContextMenuStripChangedEvent]);
4649 if (eh != null) eh (this, e);
4652 protected virtual void OnRowContextMenuStripNeeded (DataGridViewRowContextMenuStripNeededEventArgs e)
4654 DataGridViewRowContextMenuStripNeededEventHandler eh = (DataGridViewRowContextMenuStripNeededEventHandler)(Events [RowContextMenuStripNeededEvent]);
4655 if (eh != null) eh (this, e);
4658 protected internal virtual void OnRowDefaultCellStyleChanged (DataGridViewRowEventArgs e)
4660 DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowDefaultCellStyleChangedEvent]);
4661 if (eh != null) eh (this, e);
4664 protected virtual void OnRowDirtyStateNeeded (QuestionEventArgs e)
4666 QuestionEventHandler eh = (QuestionEventHandler)(Events [RowDirtyStateNeededEvent]);
4667 if (eh != null) eh (this, e);
4670 protected virtual void OnRowDividerDoubleClick (DataGridViewRowDividerDoubleClickEventArgs e)
4672 DataGridViewRowDividerDoubleClickEventHandler eh = (DataGridViewRowDividerDoubleClickEventHandler)(Events [RowDividerDoubleClickEvent]);
4673 if (eh != null) eh (this, e);
4676 protected virtual void OnRowDividerHeightChanged (DataGridViewRowEventArgs e)
4678 DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowDividerHeightChangedEvent]);
4679 if (eh != null) eh (this, e);
4682 protected virtual void OnRowEnter (DataGridViewCellEventArgs e)
4684 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [RowEnterEvent]);
4685 if (eh != null) eh (this, e);
4688 protected internal virtual void OnRowErrorTextChanged (DataGridViewRowEventArgs e)
4690 DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowErrorTextChangedEvent]);
4691 if (eh != null) eh (this, e);
4694 protected virtual void OnRowErrorTextNeeded (DataGridViewRowErrorTextNeededEventArgs e)
4696 DataGridViewRowErrorTextNeededEventHandler eh = (DataGridViewRowErrorTextNeededEventHandler)(Events [RowErrorTextNeededEvent]);
4697 if (eh != null) eh (this, e);
4700 protected internal virtual void OnRowHeaderCellChanged (DataGridViewRowEventArgs e)
4702 DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowHeaderCellChangedEvent]);
4703 if (eh != null) eh (this, e);
4706 protected virtual void OnRowHeaderMouseClick (DataGridViewCellMouseEventArgs e)
4708 DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [RowHeaderMouseClickEvent]);
4709 if (eh != null) eh (this, e);
4712 protected virtual void OnRowHeaderMouseDoubleClick (DataGridViewCellMouseEventArgs e)
4714 DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [RowHeaderMouseDoubleClickEvent]);
4715 if (eh != null) eh (this, e);
4718 protected virtual void OnRowHeadersBorderStyleChanged (EventArgs e)
4720 EventHandler eh = (EventHandler)(Events [RowHeadersBorderStyleChangedEvent]);
4721 if (eh != null) eh (this, e);
4724 protected virtual void OnRowHeadersDefaultCellStyleChanged (EventArgs e)
4726 EventHandler eh = (EventHandler)(Events [RowHeadersDefaultCellStyleChangedEvent]);
4727 if (eh != null) eh (this, e);
4730 protected virtual void OnRowHeadersWidthChanged (EventArgs e)
4732 EventHandler eh = (EventHandler)(Events [RowHeadersWidthChangedEvent]);
4733 if (eh != null) eh (this, e);
4736 protected virtual void OnRowHeadersWidthSizeModeChanged (DataGridViewAutoSizeModeEventArgs e)
4738 DataGridViewAutoSizeModeEventHandler eh = (DataGridViewAutoSizeModeEventHandler)(Events [RowHeadersWidthSizeModeChangedEvent]);
4739 if (eh != null) eh (this, e);
4742 protected internal virtual void OnRowHeightChanged (DataGridViewRowEventArgs e)
4744 DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowHeightChangedEvent]);
4745 if (eh != null) eh (this, e);
4748 protected virtual void OnRowHeightInfoNeeded (DataGridViewRowHeightInfoNeededEventArgs e)
4750 DataGridViewRowHeightInfoNeededEventHandler eh = (DataGridViewRowHeightInfoNeededEventHandler)(Events [RowHeightInfoNeededEvent]);
4751 if (eh != null) eh (this, e);
4754 protected virtual void OnRowHeightInfoPushed (DataGridViewRowHeightInfoPushedEventArgs e)
4756 DataGridViewRowHeightInfoPushedEventHandler eh = (DataGridViewRowHeightInfoPushedEventHandler)(Events [RowHeightInfoPushedEvent]);
4757 if (eh != null) eh (this, e);
4760 protected virtual void OnRowLeave (DataGridViewCellEventArgs e)
4762 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [RowLeaveEvent]);
4763 if (eh != null) eh (this, e);
4766 protected internal virtual void OnRowMinimumHeightChanged (DataGridViewRowEventArgs e)
4768 DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowMinimumHeightChangedEvent]);
4769 if (eh != null) eh (this, e);
4772 protected internal virtual void OnRowPostPaint (DataGridViewRowPostPaintEventArgs e)
4774 DataGridViewRowPostPaintEventHandler eh = (DataGridViewRowPostPaintEventHandler)(Events [RowPostPaintEvent]);
4775 if (eh != null) eh (this, e);
4778 protected internal virtual void OnRowPrePaint (DataGridViewRowPrePaintEventArgs e)
4780 DataGridViewRowPrePaintEventHandler eh = (DataGridViewRowPrePaintEventHandler)(Events [RowPrePaintEvent]);
4781 if (eh != null) eh (this, e);
4784 internal void OnRowsAddedInternal (DataGridViewRowsAddedEventArgs e)
4790 protected internal virtual void OnRowsAdded (DataGridViewRowsAddedEventArgs e)
4792 DataGridViewRowsAddedEventHandler eh = (DataGridViewRowsAddedEventHandler)(Events [RowsAddedEvent]);
4793 if (eh != null) eh (this, e);
4796 protected virtual void OnRowsDefaultCellStyleChanged (EventArgs e)
4798 EventHandler eh = (EventHandler)(Events [RowsDefaultCellStyleChangedEvent]);
4799 if (eh != null) eh (this, e);
4802 internal void OnRowsRemovedInternal (DataGridViewRowsRemovedEventArgs e)
4804 if (selected_rows != null)
4805 selected_rows.InternalClear ();
4806 if (selected_columns != null)
4807 selected_columns.InternalClear ();
4809 if (Rows.Count > 0 && Columns.Count > 0 && currentCell != null &&
4810 currentCell.RowIndex >= e.RowIndex)
4811 MoveCurrentCell (0, Math.Min (e.RowIndex, Rows.Count - 2), true, false, false, true);
4816 protected virtual void OnRowsRemoved (DataGridViewRowsRemovedEventArgs e)
4818 DataGridViewRowsRemovedEventHandler eh = (DataGridViewRowsRemovedEventHandler)(Events [RowsRemovedEvent]);
4819 if (eh != null) eh (this, e);
4822 protected internal virtual void OnRowStateChanged (int rowIndex, DataGridViewRowStateChangedEventArgs e)
4824 DataGridViewRowStateChangedEventHandler eh = (DataGridViewRowStateChangedEventHandler)(Events [RowStateChangedEvent]);
4825 if (eh != null) eh (this, e);
4828 protected virtual void OnRowUnshared (DataGridViewRowEventArgs e)
4830 DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowUnsharedEvent]);
4831 if (eh != null) eh (this, e);
4834 protected virtual void OnRowValidated (DataGridViewCellEventArgs e)
4836 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [RowValidatedEvent]);
4837 if (eh != null) eh (this, e);
4840 protected virtual void OnRowValidating (DataGridViewCellCancelEventArgs e)
4842 DataGridViewCellCancelEventHandler eh = (DataGridViewCellCancelEventHandler)(Events [RowValidatingEvent]);
4843 if (eh != null) eh (this, e);
4846 protected virtual void OnScroll (ScrollEventArgs e)
4848 ScrollEventHandler eh = (ScrollEventHandler)(Events [ScrollEvent]);
4849 if (eh != null) eh (this, e);
4852 protected virtual void OnSelectionChanged (EventArgs e)
4854 EventHandler eh = (EventHandler)(Events [SelectionChangedEvent]);
4855 if (eh != null) eh (this, e);
4858 protected virtual void OnSortCompare (DataGridViewSortCompareEventArgs e) {
4859 DataGridViewSortCompareEventHandler eh = (DataGridViewSortCompareEventHandler)(Events [SortCompareEvent]);
4860 if (eh != null) eh (this, e);
4863 protected virtual void OnSorted (EventArgs e)
4865 EventHandler eh = (EventHandler)(Events [SortedEvent]);
4866 if (eh != null) eh (this, e);
4869 protected virtual void OnUserAddedRow (DataGridViewRowEventArgs e)
4872 PrepareEditingRow (false, false);
4874 e = new DataGridViewRowEventArgs (editing_row);
4876 DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [UserAddedRowEvent]);
4877 if (eh != null) eh (this, e);
4880 protected virtual void OnUserDeletedRow (DataGridViewRowEventArgs e)
4882 DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [UserDeletedRowEvent]);
4883 if (eh != null) eh (this, e);
4887 protected virtual void OnUserDeletingRow (DataGridViewRowCancelEventArgs e)
4889 DataGridViewRowCancelEventHandler eh = (DataGridViewRowCancelEventHandler)(Events [UserDeletingRowEvent]);
4890 if (eh != null) eh (this, e);
4893 protected override void OnValidating (CancelEventArgs e)
4895 base.OnValidating(e);
4898 protected override void OnVisibleChanged (EventArgs e)
4900 base.OnVisibleChanged(e);
4903 protected virtual void PaintBackground (Graphics graphics, Rectangle clipBounds, Rectangle gridBounds)
4905 graphics.FillRectangle (ThemeEngine.Current.ResPool.GetSolidBrush (backgroundColor), gridBounds);
4908 protected bool ProcessAKey (Keys keyData)
4913 if ((keyData & Keys.Control) == Keys.Control) {
4921 protected virtual bool ProcessDataGridViewKey (KeyEventArgs e)
4923 switch (e.KeyData & ~Keys.Modifiers) {
4925 return ProcessAKey (e.KeyData);
4927 return ProcessDeleteKey (e.KeyData);
4929 return ProcessDownKey (e.KeyData);
4931 return ProcessEscapeKey (e.KeyData);
4933 return ProcessEndKey (e.KeyData);
4935 return ProcessEnterKey (e.KeyData);
4937 return ProcessF2Key (e.KeyData);
4939 return ProcessHomeKey (e.KeyData);
4941 return ProcessLeftKey (e.KeyData);
4943 return ProcessNextKey (e.KeyData);
4945 return ProcessPriorKey (e.KeyData);
4947 return ProcessRightKey (e.KeyData);
4949 return ProcessSpaceKey (e.KeyData);
4951 return ProcessTabKey (e.KeyData);
4953 return ProcessUpKey (e.KeyData);
4956 return ProcessZeroKey (e.KeyData);
4962 protected bool ProcessDeleteKey (Keys keyData)
4964 if (!allowUserToDeleteRows || SelectedRows.Count == 0)
4967 int index = Math.Max (selected_row - SelectedRows.Count + 1, 0);
4969 for (int i = SelectedRows.Count - 1; i >= 0; i--) {
4970 DataGridViewRow row = SelectedRows[i];
4975 if (hover_cell != null && hover_cell.OwningRow == row)
4978 if (DataSource != null && DataSource is DataSet)
4979 (DataSource as DataSet).Tables[dataMember].Rows.RemoveAt (row.Index);
4981 Rows.RemoveAt (row.Index);
4987 protected override bool ProcessDialogKey (Keys keyData)
4991 case Keys.Shift | Keys.Tab:
4993 return base.ProcessDialogKey (keyData & ~Keys.Control);
4995 if (ProcessDataGridViewKey (new KeyEventArgs (keyData)))
4999 case Keys.Control | Keys.Tab:
5000 case Keys.Control | Keys.Shift | Keys.Tab:
5002 return base.ProcessDialogKey (keyData & ~Keys.Control);
5004 if (ProcessDataGridViewKey (new KeyEventArgs (keyData)))
5010 if (ProcessDataGridViewKey (new KeyEventArgs (keyData)))
5016 return base.ProcessDialogKey(keyData);
5019 protected bool ProcessDownKey (Keys keyData)
5021 int current_row = CurrentCellAddress.Y;
5023 if (current_row < Rows.Count - 1) {
5024 // Move to the last cell in the column
5025 if ((keyData & Keys.Control) == Keys.Control)
5026 MoveCurrentCell (CurrentCellAddress.X, Rows.Count - 1, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5027 // Move one cell down
5029 MoveCurrentCell (CurrentCellAddress.X, current_row + 1, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5037 protected bool ProcessEndKey (Keys keyData)
5039 int disp_index = ColumnIndexToDisplayIndex (currentCellAddress.X);
5041 // Move to the last cell in the control
5042 if ((keyData & Keys.Control) == Keys.Control) {
5043 MoveCurrentCell (ColumnDisplayIndexToIndex (Columns.Count - 1), Rows.Count - 1, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5047 // Move to the last cell in the row
5048 if (disp_index < Columns.Count - 1) {
5049 MoveCurrentCell (ColumnDisplayIndexToIndex (Columns.Count - 1), currentCellAddress.Y, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5056 protected bool ProcessEnterKey (Keys keyData)
5058 if (ProcessDownKey (keyData))
5061 // ProcessDown may fail if we are on the last row,
5062 // but Enter should still EndEdit if this is the last row
5067 protected bool ProcessEscapeKey (Keys keyData)
5069 if (!IsCurrentCellInEditMode)
5076 protected bool ProcessF2Key (Keys keyData)
5078 if (editMode == DataGridViewEditMode.EditOnF2 || editMode == DataGridViewEditMode.EditOnKeystrokeOrF2) {
5086 protected bool ProcessHomeKey (Keys keyData)
5088 int disp_index = ColumnIndexToDisplayIndex (currentCellAddress.X);
5090 // Move to the first cell in the control
5091 if ((keyData & Keys.Control) == Keys.Control) {
5092 MoveCurrentCell (ColumnDisplayIndexToIndex (0), 0, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5096 // Move to the first cell in the row
5097 if (disp_index > 0) {
5098 MoveCurrentCell (ColumnDisplayIndexToIndex (0), currentCellAddress.Y, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5105 [MonoTODO ("What does insert do?")]
5106 protected bool ProcessInsertKey (Keys keyData)
5111 protected override bool ProcessKeyEventArgs (ref Message m)
5113 DataGridViewCell cell = CurrentCell;
5116 if (cell.KeyEntersEditMode (new KeyEventArgs ((Keys)m.WParam.ToInt32 ())))
5119 return base.ProcessKeyEventArgs (ref m);
5122 protected override bool ProcessKeyPreview (ref Message m)
5124 if ((Msg)m.Msg == Msg.WM_KEYDOWN && (IsCurrentCellInEditMode || m.HWnd == horizontalScrollBar.Handle || m.HWnd == verticalScrollBar.Handle)) {
5125 KeyEventArgs e = new KeyEventArgs ((Keys)m.WParam.ToInt32 ());
5127 IDataGridViewEditingControl ctrl = (IDataGridViewEditingControl)EditingControlInternal;
5130 if (ctrl.EditingControlWantsInputKey (e.KeyData, false))
5133 switch (e.KeyData) {
5142 return ProcessDataGridViewKey (e);
5146 return base.ProcessKeyPreview (ref m);
5149 protected bool ProcessLeftKey (Keys keyData)
5151 int disp_index = ColumnIndexToDisplayIndex (currentCellAddress.X);
5153 if (disp_index > 0) {
5154 // Move to the first cell in the row
5155 if ((keyData & Keys.Control) == Keys.Control)
5156 MoveCurrentCell (ColumnDisplayIndexToIndex (0), currentCellAddress.Y, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5157 // Move one cell to the left
5159 MoveCurrentCell (ColumnDisplayIndexToIndex (disp_index - 1), currentCellAddress.Y, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5168 protected bool ProcessNextKey (Keys keyData)
5170 int current_row = CurrentCellAddress.Y;
5172 if (current_row < Rows.Count - 1) {
5173 // Move one "page" of cells down
5174 int new_row = Math.Min (Rows.Count - 1, current_row + DisplayedRowCount (false));
5176 MoveCurrentCell (CurrentCellAddress.X, new_row, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5185 protected bool ProcessPriorKey (Keys keyData)
5187 int current_row = CurrentCellAddress.Y;
5189 if (current_row > 0) {
5190 // Move one "page" of cells up
5191 int new_row = Math.Max (0, current_row - DisplayedRowCount (false));
5193 MoveCurrentCell (CurrentCellAddress.X, new_row, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5201 protected bool ProcessRightKey (Keys keyData)
5203 int disp_index = ColumnIndexToDisplayIndex (currentCellAddress.X);
5205 if (disp_index < Columns.Count - 1) {
5206 // Move to the last cell in the row
5207 if ((keyData & Keys.Control) == Keys.Control)
5208 MoveCurrentCell (ColumnDisplayIndexToIndex (Columns.Count - 1), currentCellAddress.Y, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5209 // Move one cell to the right
5211 MoveCurrentCell (ColumnDisplayIndexToIndex (disp_index + 1), currentCellAddress.Y, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5219 protected bool ProcessSpaceKey (Keys keyData)
5221 if ((keyData & Keys.Shift) == Keys.Shift) {
5222 if (selectionMode == DataGridViewSelectionMode.RowHeaderSelect) {
5223 SetSelectedRowCore (CurrentCellAddress.Y, true);
5224 InvalidateRow (CurrentCellAddress.Y);
5227 if (selectionMode == DataGridViewSelectionMode.ColumnHeaderSelect) {
5228 SetSelectedColumnCore (CurrentCellAddress.X, true);
5229 InvalidateColumn (CurrentCellAddress.X);
5234 if (CurrentCell is DataGridViewButtonCell || CurrentCell is DataGridViewLinkCell || CurrentCell is DataGridViewCheckBoxCell) {
5235 DataGridViewCellEventArgs e = new DataGridViewCellEventArgs (CurrentCell.ColumnIndex, CurrentCell.RowIndex);
5238 OnCellContentClick (e);
5240 if (CurrentCell is DataGridViewButtonCell)
5241 (CurrentCell as DataGridViewButtonCell).OnClickInternal (e);
5242 if (CurrentCell is DataGridViewCheckBoxCell)
5243 (CurrentCell as DataGridViewCheckBoxCell).OnClickInternal (e);
5251 protected bool ProcessTabKey (Keys keyData)
5253 Form f = FindForm ();
5256 f.ActivateFocusCues ();
5258 int disp_index = ColumnIndexToDisplayIndex (currentCellAddress.X);
5261 // Shift-tab goes backwards
5262 if ((keyData & Keys.Shift) == Keys.Shift) {
5263 if (disp_index > 0) {
5264 // Move one cell to the left
5265 MoveCurrentCell (ColumnDisplayIndexToIndex (disp_index - 1), currentCellAddress.Y, true, (keyData & Keys.Control) == Keys.Control, false, true);
5267 } else if (currentCellAddress.Y > 0) {
5268 // Move to the last cell in the previous row
5269 MoveCurrentCell (ColumnDisplayIndexToIndex (Columns.Count - 1), currentCellAddress.Y - 1, true, false, false, true);
5274 if (disp_index < Columns.Count - 1) {
5275 // Move one cell to the right
5276 MoveCurrentCell (ColumnDisplayIndexToIndex (disp_index + 1), currentCellAddress.Y, true, (keyData & Keys.Control) == Keys.Control, false, true);
5279 } else if (currentCellAddress.Y < Rows.Count - 1) {
5280 // Move to the first cell in the next row
5281 MoveCurrentCell (ColumnDisplayIndexToIndex (0), currentCellAddress.Y + 1, true, false, false, true);
5291 protected bool ProcessUpKey (Keys keyData)
5293 int current_row = CurrentCellAddress.Y;
5295 if (current_row > 0) {
5296 // Move to the first cell in the column
5297 if ((keyData & Keys.Control) == Keys.Control)
5298 MoveCurrentCell (CurrentCellAddress.X, 0, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5301 MoveCurrentCell (CurrentCellAddress.X, current_row - 1, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5309 protected bool ProcessZeroKey (Keys keyData)
5311 if ((keyData & Keys.Control) == Keys.Control && CurrentCell.EditType != null) {
5312 CurrentCell.Value = DBNull.Value;
5313 InvalidateCell (CurrentCell);
5320 protected override void SetBoundsCore (int x, int y, int width, int height, BoundsSpecified specified) {
5321 base.SetBoundsCore(x, y, width, height, specified);
5324 [MonoTODO ("Does not use validateCurrentCell")]
5325 protected virtual bool SetCurrentCellAddressCore (int columnIndex, int rowIndex, bool setAnchorCellAddress, bool validateCurrentCell, bool throughMouseClick)
5327 if ((columnIndex < 0 || columnIndex > Columns.Count - 1) && rowIndex != -1)
5328 throw new ArgumentOutOfRangeException ("columnIndex");
5329 if ((rowIndex < 0 || rowIndex > Rows.Count - 1) && columnIndex != -1)
5330 throw new ArgumentOutOfRangeException ("rowIndex");
5332 DataGridViewCell cell;
5334 if (columnIndex == -1 && rowIndex == -1)
5337 cell = Rows.SharedRow (rowIndex).Cells[columnIndex];
5339 if (cell != null && !cell.Visible)
5340 throw new InvalidOperationException ("cell is not visible");
5342 if (setAnchorCellAddress)
5343 anchor_cell = new Point (columnIndex, rowIndex);
5345 if (cell != currentCell) {
5346 if (currentCell != null) {
5347 if (currentCell.IsInEditMode)
5349 OnCellLeave (new DataGridViewCellEventArgs(currentCell.ColumnIndex, currentCell.RowIndex));
5350 OnRowLeave (new DataGridViewCellEventArgs (currentCell.ColumnIndex, currentCell.RowIndex));
5354 currentCellAddress = new Point (columnIndex, rowIndex);
5356 UpdateBindingPosition (currentCell.RowIndex);
5357 OnRowEnter (new DataGridViewCellEventArgs (cell.ColumnIndex, cell.RowIndex));
5358 OnCellEnter (new DataGridViewCellEventArgs(cell.ColumnIndex, cell.RowIndex));
5359 OnCurrentCellChanged (EventArgs.Empty);
5360 if (throughMouseClick && editMode == DataGridViewEditMode.EditOnEnter)
5363 if (throughMouseClick)
5370 protected virtual void SetSelectedCellCore (int columnIndex, int rowIndex, bool selected) {
5371 rows [rowIndex].Cells [columnIndex].Selected = selected;
5373 OnSelectionChanged (EventArgs.Empty);
5376 internal void SetSelectedColumnCoreInternal (int columnIndex, bool selected) {
5377 SetSelectedColumnCore (columnIndex, selected);
5380 protected virtual void SetSelectedColumnCore (int columnIndex, bool selected) {
5381 if (selectionMode != DataGridViewSelectionMode.ColumnHeaderSelect && selectionMode != DataGridViewSelectionMode.FullColumnSelect)
5384 DataGridViewColumn col = columns [columnIndex];
5386 col.SelectedInternal = selected;
5388 if (selected_columns == null)
5389 selected_columns = new DataGridViewSelectedColumnCollection ();
5391 if (!selected && selected_columns.Contains (col)) {
5392 selected_columns.InternalRemove (col);
5393 } else if (selected && !selected_columns.Contains (col)) {
5394 selected_columns.InternalAdd (col);
5400 internal void SetSelectedRowCoreInternal (int rowIndex, bool selected) {
5401 SetSelectedRowCore (rowIndex, selected);
5404 protected virtual void SetSelectedRowCore (int rowIndex, bool selected) {
5405 DataGridViewRow row = rows [rowIndex];
5407 row.SelectedInternal = selected;
5409 if (selected_rows == null)
5410 selected_rows = new DataGridViewSelectedRowCollection (this);
5412 if (!selected && selected_rows.Contains (row)) {
5413 selected_rows.InternalRemove (row);
5414 } else if (selected && !selected_rows.Contains (row)) {
5415 selected_rows.InternalAdd (row);
5421 protected override void WndProc (ref Message m)
5423 base.WndProc (ref m);
5426 internal void InternalOnCellClick (DataGridViewCellEventArgs e)
5431 internal void InternalOnCellContentClick (DataGridViewCellEventArgs e)
5433 OnCellContentClick (e);
5436 internal void InternalOnCellContentDoubleClick (DataGridViewCellEventArgs e)
5438 OnCellContentDoubleClick (e);
5441 internal void InternalOnCellValueChanged (DataGridViewCellEventArgs e)
5443 OnCellValueChanged (e);
5446 internal void InternalOnDataError (DataGridViewDataErrorEventArgs e)
5448 /////////////// false? ////////////
5449 OnDataError (false, e);
5452 internal void InternalOnMouseWheel (MouseEventArgs e)
5457 internal void OnHScrollBarScroll (object sender, ScrollEventArgs e)
5459 horizontalScrollingOffset = e.NewValue;
5462 for (int index = 0; index < Columns.Count; index++) {
5463 DataGridViewColumn col = Columns[index];
5465 if (e.NewValue < left + col.Width) {
5466 if (first_col_index != index) {
5467 first_col_index = index;
5479 internal void OnVScrollBarScroll (object sender, ScrollEventArgs e)
5481 verticalScrollingOffset = e.NewValue;
5482 if (Rows.Count == 0)
5487 for (int index = 0; index < Rows.Count; index++) {
5488 DataGridViewRow row = Rows[index];
5489 if (e.NewValue < top + row.Height) {
5490 if (first_row_index != index) {
5491 first_row_index = index;
5502 first_row_index = Rows.Count - DisplayedRowCount (false);
5507 internal void RaiseCellStyleChanged (DataGridViewCellEventArgs e) {
5508 OnCellStyleChanged(e);
5511 internal void OnColumnCollectionChanged (object sender, CollectionChangeEventArgs e) {
5513 case CollectionChangeAction.Add:
5514 OnColumnAddedInternal(new DataGridViewColumnEventArgs(e.Element as DataGridViewColumn));
5516 case CollectionChangeAction.Remove:
5517 OnColumnRemovedInternal(new DataGridViewColumnEventArgs(e.Element as DataGridViewColumn));
5519 case CollectionChangeAction.Refresh:
5524 // Resizes all columns according to their AutoResizeMode property.
5525 // First all the columns that aren't Filled are resized, then we resize all the Filled columns.
5526 internal void AutoResizeColumnsInternal ()
5528 for (int i = 0; i < Columns.Count; i++)
5529 AutoResizeColumnInternal (i, Columns [i].InheritedAutoSizeMode);
5531 AutoFillColumnsInternal ();
5534 internal void AutoFillColumnsInternal ()
5536 float totalFillWeight = 0;
5537 int FillCount = 0; // The number of columns that has AutoSizeMode.Fill set
5538 int spaceLeft = ClientSize.Width - (verticalScrollBar.VisibleInternal ? verticalScrollBar.Width : 0);
5540 if (RowHeadersVisible) {
5541 spaceLeft -= RowHeadersWidth;
5543 spaceLeft -= BorderWidth * 2;
5545 int [] fixed_widths = new int [Columns.Count];
5546 int [] new_widths = new int [Columns.Count];
5547 bool fixed_any = false;
5549 for (int i = 0; i < Columns.Count; i++) {
5550 DataGridViewColumn col = Columns [i];
5552 switch (col.InheritedAutoSizeMode) {
5553 case DataGridViewAutoSizeColumnMode.Fill:
5555 totalFillWeight += col.FillWeight;
5557 case DataGridViewAutoSizeColumnMode.AllCellsExceptHeader:
5558 case DataGridViewAutoSizeColumnMode.AllCells:
5559 case DataGridViewAutoSizeColumnMode.DisplayedCells:
5560 case DataGridViewAutoSizeColumnMode.DisplayedCellsExceptHeader:
5561 case DataGridViewAutoSizeColumnMode.None:
5562 case DataGridViewAutoSizeColumnMode.NotSet:
5563 spaceLeft -= Columns [i].Width;
5568 spaceLeft = Math.Max (0, spaceLeft);
5572 for (int i = 0; i < columns.Count; i++) {
5573 DataGridViewColumn col = Columns [i];
5576 if (col.InheritedAutoSizeMode != DataGridViewAutoSizeColumnMode.Fill)
5579 if (fixed_widths [i] != 0)
5582 width = (totalFillWeight == 0) ? 0 : (int) Math.Round (spaceLeft * (col.FillWeight / totalFillWeight), 0);
5587 if (width < col.MinimumWidth) {
5588 width = col.MinimumWidth;
5589 fixed_widths [i] = width;
5592 totalFillWeight -= col.FillWeight;
5595 new_widths [i] = width;
5597 } while (fixed_any);
5599 for (int i = 0; i < columns.Count; i++) {
5600 if (Columns [i].InheritedAutoSizeMode != DataGridViewAutoSizeColumnMode.Fill)
5603 Columns [i].Width = new_widths [i];
5607 internal void AutoResizeColumnInternal (int columnIndex, DataGridViewAutoSizeColumnMode mode)
5609 // http://msdn2.microsoft.com/en-us/library/ms171605.aspx
5612 DataGridViewColumn col = Columns [columnIndex];
5615 case DataGridViewAutoSizeColumnMode.Fill:
5617 case DataGridViewAutoSizeColumnMode.AllCellsExceptHeader:
5618 case DataGridViewAutoSizeColumnMode.AllCells:
5619 case DataGridViewAutoSizeColumnMode.DisplayedCells:
5620 case DataGridViewAutoSizeColumnMode.DisplayedCellsExceptHeader:
5621 size = Math.Max (CalculateColumnCellWidth (columnIndex, col.InheritedAutoSizeMode),
5622 col.HeaderCell.ContentBounds.Width);
5624 case DataGridViewAutoSizeColumnMode.ColumnHeader:
5625 size = col.HeaderCell.ContentBounds.Width;
5634 if (size < col.MinimumWidth)
5635 size = col.MinimumWidth;
5640 internal int CalculateColumnCellWidth (int index, DataGridViewAutoSizeColumnMode mode)
5644 bool only_visible = false;
5646 if (mode == DataGridViewAutoSizeColumnMode.DisplayedCellsExceptHeader ||
5647 mode == DataGridViewAutoSizeColumnMode.AllCellsExceptHeader)
5650 only_visible = (mode == DataGridViewAutoSizeColumnMode.DisplayedCells || mode == DataGridViewAutoSizeColumnMode.DisplayedCellsExceptHeader);
5652 for (int i = first_row; i < Rows.Count; i++) {
5654 Rectangle row_rect = this.GetRowDisplayRectangle (i, false);
5655 if (!ClientRectangle.IntersectsWith (row_rect))
5659 int cell_width = Rows[i].Cells[index].PreferredSize.Width;
5661 result = Math.Max (result, cell_width);
5667 Rectangle GetHeaderCellBounds (DataGridViewHeaderCell cell)
5669 Rectangle bounds = new Rectangle (ClientRectangle.Location, cell.Size);
5670 if (cell is DataGridViewColumnHeaderCell) {
5671 if (RowHeadersVisible)
5672 bounds.X += RowHeadersWidth;
5673 List<DataGridViewColumn> sortedColumns = columns.ColumnDisplayIndexSortedArrayList;
5674 for (int index = first_col_index; index < sortedColumns.Count; index++) {
5675 DataGridViewColumn column = sortedColumns [index];
5676 if (column.Index == cell.ColumnIndex)
5678 bounds.X += column.Width;
5681 if (ColumnHeadersVisible)
5682 bounds.Y += ColumnHeadersHeight;
5683 for (int index = first_row_index; index < Rows.Count; index++) {
5684 DataGridViewRow row = GetRowInternal (index);
5685 if (row.HeaderCell == cell)
5687 bounds.Y += row.Height;
5693 internal void PrepareEditingRow (bool cell_changed, bool column_changed)
5697 show = ColumnCount > 0 && AllowUserToAddRows;
5699 if (!show && editing_row != null) {
5700 Rows.RemoveInternal (editing_row);
5703 if (editing_row != null) {
5705 // The row changed, it's no longer an editing row.
5707 } else if (column_changed) {
5708 // The number of columns has changed, we need a new editing row.
5709 Rows.RemoveInternal (editing_row);
5713 if (editing_row == null) {
5714 editing_row = RowTemplateFull;
5715 Rows.AddInternal (editing_row, false);
5722 internal DataGridViewRow EditingRow {
5723 get { return editing_row; }
5726 private void BindIList (IList list) {
5727 if (autoGenerateColumns) {
5728 // Stuff from a DataSet
5729 if (list is DataView) {
5730 DataView dataView = (DataView) list;
5731 DataTable table = dataView.Table;
5733 foreach (DataColumn dataColumn in table.Columns) {
5734 DataGridViewColumn col = CreateColumnByType (dataColumn.DataType);
5736 col.Name = dataColumn.ColumnName;
5737 col.DataPropertyName = dataColumn.ColumnName;
5738 col.SetIsDataBound (true);
5739 col.ValueType = dataColumn.DataType;
5740 col.AutoGenerated = true;
5745 // Its a generic something or other, like a BindingList<T>, so
5746 // we can figure out the type from the generic type
5747 else if (list.GetType ().GetGenericArguments ().Length > 0) {
5748 GenerateColumnsFromType (list.GetType ().GetGenericArguments ()[0]);
5750 // Its a normal array/collection type thing
5751 else if (list.GetType ().IsArray) {
5752 GenerateColumnsFromType (list.GetType ().GetElementType ());
5753 } else if (list is BindingSource && (list as BindingSource).item_type != null) {
5754 foreach (PropertyDescriptor property in TypeDescriptor.GetProperties ((list as BindingSource).item_type)) {
5755 DataGridViewColumn col = CreateColumnByType (property.PropertyType);
5756 col.Name = property.DisplayName;
5757 col.ReadOnly = property.IsReadOnly;
5758 col.AutoGenerated = true;
5762 AllowUserToAddRows = (list as BindingSource).AllowNew;
5766 // Subscribe to the dataset's change notification
5767 if (list is DataView) {
5768 (list as DataView).ListChanged += OnListChanged;
5769 (list as DataView).Table.ColumnChanged += OnTableColumnChanged;
5770 (list as DataView).Table.TableCleared += OnTableCleared;
5774 foreach (object element in list)
5775 AddBoundRow (element);
5778 private void OnBindingSourceDataSourceChanged (object sender, EventArgs args)
5784 private void AddBoundRow (object element)
5786 // Don't add rows if there are no columns
5787 if (ColumnCount == 0)
5790 DataGridViewRow row = (DataGridViewRow)RowTemplateFull;
5791 rows.InternalAdd (row);
5793 PropertyDescriptorCollection properties = TypeDescriptor.GetProperties (element);
5795 foreach (PropertyDescriptor property in properties) {
5796 if (property.PropertyType == typeof (IBindingList))
5799 // We do it this way because there may not be a column
5800 // for every cell, ignore cells with no column
5801 DataGridViewCell cell = row.Cells.GetBoundCell (property.Name);
5806 cell.valuex = property.GetValue (element);
5807 cell.valueType = property.PropertyType;
5811 private void GenerateColumnsFromType (Type type)
5813 foreach (PropertyDescriptor property in TypeDescriptor.GetProperties (type)) {
5814 // This keeps out things like arrays
5815 if ((typeof(ICollection).IsAssignableFrom (property.PropertyType)))
5818 DataGridViewColumn col = CreateColumnByType (property.PropertyType);
5819 col.Name = property.DisplayName;
5820 col.DataPropertyName = property.DisplayName;
5821 col.ReadOnly = property.IsReadOnly;
5822 col.SetIsDataBound (true);
5823 col.ValueType = property.PropertyType;
5824 col.AutoGenerated = true;
5829 private DataGridViewColumn CreateColumnByType (Type type)
5831 if (type == typeof (bool))
5832 return new DataGridViewCheckBoxColumn ();
5834 return new DataGridViewTextBoxColumn ();
5837 private void ClearBinding ()
5839 columns.ClearAutoGeneratedColumns ();
5841 PrepareEditingRow (false, true);
5843 if (dataSource != null) {
5844 if (dataSource is DataSet) {
5845 (dataSource as DataSet).Tables.CollectionChanged -= OnDataSetTableChanged;
5847 DataTable dt = (dataSource as DataSet).Tables[dataMember];
5850 DataView dv = dt.DefaultView;
5853 (dv as DataView).Table.ColumnChanged -= OnTableColumnChanged;
5854 (dv as DataView).ListChanged -= OnListChanged;
5857 } else if (dataSource is DataView) {
5858 (dataSource as DataView).ListChanged -= OnListChanged;
5859 (dataSource as DataView).Table.ColumnChanged -= OnTableColumnChanged;
5860 } else if (dataSource is DataTable)
5861 ((dataSource as IListSource).GetList () as DataView).ListChanged -= OnListChanged;
5863 if (dataSource is IBindingList)
5864 (dataSource as IBindingList).ListChanged -= OnListChanged;
5865 if (dataSource is BindingSource)
5866 (dataSource as BindingSource).DataSourceChanged -= OnBindingSourceDataSourceChanged;
5870 private void DoBinding ()
5872 /* 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:
5873 - the System.Collections.IList interface, including one-dimensional arrays.
5874 - the System.ComponentModel.IListSource interface, such as the System.Data.DataTable and System.Data.DataSet classes.
5875 - the System.ComponentModel.IBindingList interface, such as the System.ComponentModel.Collections.BindingList<> class.
5876 - the System.ComponentModel.IBindingListView interface, such as the System.Windows.Forms.BindingSource class.
5879 if (dataSource != null) {
5880 object value = dataSource;
5883 if (value is DataSet && string.IsNullOrEmpty (dataMember)) {
5887 if (value is DataSet) {
5888 (value as DataSet).Tables.CollectionChanged += OnDataSetTableChanged;
5889 value = (value as DataSet).Tables[dataMember];
5892 if (value is BindingSource)
5893 BindBindingSource (value as BindingSource);
5894 else if (value is IBindingListView)
5895 BindIBindingListView (value as IBindingListView);
5896 else if (value is IBindingList)
5897 BindIBindingList (value as IBindingList);
5898 else if (value is IList)
5899 BindIList (value as IList);
5900 else if (value is IListSource)
5901 BindIListSource (value as IListSource);
5903 OnDataBindingComplete (new DataGridViewBindingCompleteEventArgs (ListChangedType.Reset));
5906 if (Rows.Count > 0 && Columns.Count > 0)
5907 MoveCurrentCell (0, 0, true, false, false, false);
5912 private void BindBindingSource (BindingSource bindingSource)
5914 BindIList (bindingSource.List);
5915 bindingSource.ListChanged += OnBindingSourceDataSourceChanged;
5916 bindingSource.DataSourceChanged += OnBindingSourceDataSourceChanged;
5919 private void BindIListSource (IListSource list) {
5920 BindIList (list.GetList());
5923 private void BindIBindingList (IBindingList list) {
5925 list.ListChanged += OnListChanged;
5928 private void BindIBindingListView (IBindingListView list) {
5932 private void MoveCurrentCell (int x, int y, bool select, bool isControl, bool isShift, bool scroll)
5934 SetCurrentCellAddressCore (x, y, true, false, false);
5936 bool full_row_selected = Rows.SharedRow(CurrentCellAddress.Y).Selected;
5937 bool full_col_selected = Columns[CurrentCellAddress.X].Selected;
5940 DataGridViewSelectionMode mode = selectionMode;
5942 // If we are row header select and we clicked a row header, use full row
5943 if (mode == DataGridViewSelectionMode.RowHeaderSelect && (x == -1 || (full_row_selected && CurrentCellAddress.X == x)))
5944 mode = DataGridViewSelectionMode.FullRowSelect;
5945 else if (mode == DataGridViewSelectionMode.RowHeaderSelect)
5946 mode = DataGridViewSelectionMode.CellSelect;
5948 // If we are col header select and we clicked a col header, use full col
5949 if (mode == DataGridViewSelectionMode.ColumnHeaderSelect && (y == -1 || (full_col_selected && CurrentCellAddress.Y == y)))
5950 mode = DataGridViewSelectionMode.FullColumnSelect;
5951 else if (mode == DataGridViewSelectionMode.ColumnHeaderSelect)
5952 mode = DataGridViewSelectionMode.CellSelect;
5954 // If the current cell isn't visible, scroll to it
5956 int disp_x = ColumnIndexToDisplayIndex (x);
5958 if (disp_x < first_col_index) {
5962 delta_x = horizontalScrollBar.Value;
5964 for (int i = disp_x; i < first_col_index; i++)
5965 delta_x += Columns[ColumnDisplayIndexToIndex (i)].Width;
5967 horizontalScrollBar.SafeValueSet (horizontalScrollBar.Value - delta_x);
5968 OnHScrollBarScroll (this, new ScrollEventArgs (ScrollEventType.ThumbPosition, horizontalScrollBar.Value));
5972 int displayedRowsCount = DisplayedRowCount (false);
5975 if (disp_y < first_row_index) {
5977 delta_y = verticalScrollBar.Value;
5979 for (int i = disp_y; i < first_row_index; i++)
5980 delta_y += GetRowInternal (i).Height;
5982 verticalScrollBar.SafeValueSet (verticalScrollBar.Value - delta_y);
5983 OnVScrollBarScroll (this, new ScrollEventArgs (ScrollEventType.ThumbPosition, verticalScrollBar.Value));
5984 } else if (disp_y > first_row_index + displayedRowsCount - 1) {
5985 if (disp_y == Rows.Count - 1)
5986 delta_y = verticalScrollBar.Maximum - verticalScrollBar.Value;
5988 for (int i = first_row_index + displayedRowsCount - 1; i < disp_y; i++)
5989 delta_y += GetRowInternal (i).Height;
5991 verticalScrollBar.SafeValueSet (verticalScrollBar.Value + delta_y);
5992 OnVScrollBarScroll (this, new ScrollEventArgs (ScrollEventType.ThumbPosition, verticalScrollBar.Value));
5999 // Clear old selection unless multi-selecting
6004 case DataGridViewSelectionMode.CellSelect:
6005 SetSelectedCellCore (x, y, true);
6007 case DataGridViewSelectionMode.FullRowSelect:
6008 SetSelectedRowCore (y, true);
6010 case DataGridViewSelectionMode.FullColumnSelect:
6011 SetSelectedColumnCore (x, true);
6018 private int ColumnIndexToDisplayIndex (int index)
6020 return Columns[index].DisplayIndex;
6023 private int ColumnDisplayIndexToIndex (int index)
6025 return Columns.ColumnDisplayIndexSortedArrayList[index].Index;
6028 private void OnListChanged (object sender, ListChangedEventArgs args)
6030 switch (args.ListChangedType) {
6031 case ListChangedType.ItemAdded:
6032 AddBoundRow ((sender as IBindingList)[args.NewIndex]);
6034 case ListChangedType.ItemDeleted:
6035 Rows.RemoveAt (args.NewIndex);
6046 private void OnTableColumnChanged (object sender, DataColumnChangeEventArgs e)
6052 private void OnDataSetTableChanged (object sender, CollectionChangeEventArgs e)
6058 private void OnTableCleared (object sender, DataTableClearEventArgs e)
6064 private bool MouseOverColumnResize (int col, int mousex)
6066 if (!allowUserToResizeColumns)
6069 Rectangle col_bounds = GetCellDisplayRectangle (col, 0, false);
6071 if (mousex >= col_bounds.Right - 4 && mousex <= col_bounds.Right)
6077 private bool MouseOverRowResize (int row, int mousey)
6079 if (!allowUserToResizeRows)
6082 Rectangle row_bounds = GetCellDisplayRectangle (0, row, false);
6084 if (mousey >= row_bounds.Bottom - 4 && mousey <= row_bounds.Bottom)
6090 private void DrawVerticalResizeLine (int x)
6092 Rectangle splitter = new Rectangle (x, Bounds.Y + 3 + (ColumnHeadersVisible ? ColumnHeadersHeight : 0), 1, Bounds.Height - 3 - (ColumnHeadersVisible ? ColumnHeadersHeight : 0));
6093 XplatUI.DrawReversibleRectangle (Handle, splitter, 2);
6096 private void DrawHorizontalResizeLine (int y)
6098 Rectangle splitter = new Rectangle (Bounds.X + 3 + (RowHeadersVisible ? RowHeadersWidth : 0), y, Bounds.Width - 3 + (RowHeadersVisible ? RowHeadersWidth : 0), 1);
6099 XplatUI.DrawReversibleRectangle (Handle, splitter, 2);
6102 #region Stuff for ToolTips
6103 private void MouseEnteredErrorIcon (DataGridViewCell item)
6105 tooltip_currently_showing = item;
6106 ToolTipTimer.Start ();
6109 private void MouseLeftErrorIcon (DataGridViewCell item)
6111 ToolTipTimer.Stop ();
6112 ToolTipWindow.Hide (this);
6113 tooltip_currently_showing = null;
6116 private Timer ToolTipTimer {
6118 if (tooltip_timer == null) {
6119 tooltip_timer = new Timer ();
6120 tooltip_timer.Enabled = false;
6121 tooltip_timer.Interval = 500;
6122 tooltip_timer.Tick += new EventHandler (ToolTipTimer_Tick);
6125 return tooltip_timer;
6129 private ToolTip ToolTipWindow {
6131 if (tooltip_window == null)
6132 tooltip_window = new ToolTip ();
6134 return tooltip_window;
6138 private void ToolTipTimer_Tick (object o, EventArgs args)
6140 string tooltip = tooltip_currently_showing.ErrorText;
6142 if (!string.IsNullOrEmpty (tooltip))
6143 ToolTipWindow.Present (this, tooltip);
6145 ToolTipTimer.Stop ();
6149 private class ColumnSorter : IComparer
6155 public ColumnSorter (DataGridViewColumn column, ListSortDirection direction, bool numeric)
6157 this.column = column.Index;
6158 this.numeric_sort = numeric;
6160 if (direction == ListSortDirection.Descending)
6161 this.direction = -1;
6164 #region IComparer Members
6165 public int Compare (object x, object y)
6167 DataGridViewRow row1 = (DataGridViewRow)x;
6168 DataGridViewRow row2 = (DataGridViewRow)y;
6170 if (row1.Cells[column].ValueType == typeof (DateTime) && row2.Cells[column].ValueType == typeof (DateTime))
6171 return DateTime.Compare ((DateTime)row1.Cells[column].valuex, (DateTime)row2.Cells[column].valuex) * direction;
6173 object val1 = row1.Cells[column].FormattedValue;
6174 object val2 = row2.Cells[column].FormattedValue;
6176 if (val1 == null && val2 == null)
6181 return -1 * direction;
6184 return (int)(double.Parse (val1.ToString ()) - double.Parse (val2.ToString ())) * direction;
6186 return string.Compare (val1.ToString (), val2.ToString ()) * direction;
6191 public sealed class HitTestInfo {
6193 public static readonly HitTestInfo Nowhere = new HitTestInfo(-1, -1, -1, -1, DataGridViewHitTestType.None);
6195 private int columnIndex;
6196 private int columnX;
6197 private int rowIndex;
6199 private DataGridViewHitTestType type;
6201 internal HitTestInfo (int columnIndex, int columnX, int rowIndex, int rowY, DataGridViewHitTestType type) {
6202 this.columnIndex = columnIndex;
6203 this.columnX = columnX;
6204 this.rowIndex = rowIndex;
6209 public int ColumnIndex {
6210 get { return columnIndex; }
6213 public int ColumnX {
6214 get { return columnX; }
6217 public int RowIndex {
6218 get { return rowIndex; }
6222 get { return rowY; }
6225 public DataGridViewHitTestType Type {
6226 get { return type; }
6229 public override bool Equals (object value) {
6230 if (value is HitTestInfo) {
6231 HitTestInfo aux = (HitTestInfo) value;
6232 if (aux.columnIndex == columnIndex && aux.columnX == columnX && aux.rowIndex == rowIndex && aux.rowY == rowY && aux.type == type) {
6239 public override int GetHashCode () {
6240 return base.GetHashCode();
6243 public override string ToString () {
6244 return string.Format ("Type:{0}, Column:{1}, Row:{2}", type, columnIndex, rowIndex);
6249 [ComVisible (false)]
6250 public class DataGridViewControlCollection : Control.ControlCollection
6252 private DataGridView owner;
6254 public DataGridViewControlCollection (DataGridView owner) : base (owner)
6259 public override void Clear ()
6262 // This is severely buggy, just as MS' implementation is.
6264 for (int i = 0; i < Count; i++) {
6269 public void CopyTo (Control [] array, int index)
6271 base.CopyTo (array, index);
6274 public void Insert (int index, Control value)
6276 throw new NotSupportedException ();
6279 public override void Remove (Control value)
6281 if (value == owner.horizontalScrollBar)
6284 if (value == owner.verticalScrollBar)
6287 if (value == owner.editingControl)
6290 base.Remove (value);
6293 internal void RemoveInternal (Control value)
6295 base.Remove (value);
6301 [ComVisibleAttribute(true)]
6302 protected class DataGridViewAccessibleObject : ControlAccessibleObject {
6304 public DataGridViewAccessibleObject (DataGridView owner) : base (owner){
6307 public override AccessibleRole Role {
6308 get { return base.Role; }
6311 public override string Name {
6312 get { return base.Name; }
6315 public override AccessibleObject GetChild (int index) {
6316 return base.GetChild(index);
6319 public override int GetChildCount () {
6320 return base.GetChildCount();
6323 public override AccessibleObject GetFocused () {
6324 return base.GetFocused();
6327 public override AccessibleObject GetSelected () {
6328 return base.GetSelected();
6331 public override AccessibleObject HitTest (int x, int y) {
6332 return base.HitTest(x, y);
6335 public override AccessibleObject Navigate( AccessibleNavigation navigationDirection) {
6336 return base.Navigate(navigationDirection);
6342 protected class DataGridViewTopRowAccessibleObject : AccessibleObject
6344 #region Constructors
6345 public DataGridViewTopRowAccessibleObject ()
6349 public DataGridViewTopRowAccessibleObject (DataGridView owner)
6355 #region Public Methods
6356 public override AccessibleObject GetChild (int index)
6358 return base.GetChild (index);
6361 public override int GetChildCount ()
6363 return base.GetChildCount ();
6366 public override AccessibleObject Navigate (AccessibleNavigation navigationDirection)
6368 return base.Navigate (navigationDirection);
6372 #region Public Properties
6373 public override Rectangle Bounds {
6374 get { return base.Bounds; }
6377 public override string Name {
6378 get { return base.Name; }
6381 public DataGridView Owner {
6382 get { return (DataGridView)owner; }
6385 throw new InvalidOperationException ("owner has already been set");
6391 public override AccessibleObject Parent {
6392 get { return base.Parent; }
6395 public override AccessibleRole Role {
6396 get { return base.Role; }
6399 public override string Value {
6400 get { return base.Value; }