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 IDataGridViewEditingControl dgvEditingControl = (IDataGridViewEditingControl) EditingControlInternal;
2289 if (dgvEditingControl != null) {
2290 dgvEditingControl.EditingControlDataGridView = this;
2291 dgvEditingControl.EditingControlRowIndex = currentCell.OwningRow.Index;
2292 dgvEditingControl.ApplyCellStyleToEditingControl (style);
2293 dgvEditingControl.PrepareEditingControlForEdit (selectAll);
2294 dgvEditingControl.EditingControlFormattedValue = currentCell.EditedFormattedValue;
2299 // If we are here, it means we have a cell that does not have an editing control
2300 // and simply implements IDataGridViewEditingCell itself.
2301 (cell as IDataGridViewEditingCell).PrepareEditingCellForEdit (selectAll);
2306 public bool CancelEdit ()
2308 if (currentCell != null && currentCell.IsInEditMode) {
2309 // The user's typing caused a new row to be created, but
2310 // now they are canceling that typing, we have to remove
2311 // the new row we added.
2312 if (!new_row_commited) {
2313 DataGridViewRow delete_row = EditingRow;
2314 Rows.RemoveInternal (delete_row);
2315 editing_row = Rows[currentCell.RowIndex];
2316 OnUserDeletedRow (new DataGridViewRowEventArgs (delete_row));
2317 new_row_commited = true;
2320 currentCell.SetIsInEditMode (false);
2321 currentCell.DetachEditingControl ();
2322 OnCellEndEdit (new DataGridViewCellEventArgs (currentCell.ColumnIndex, currentCell.RowIndex));
2328 public void ClearSelection ()
2330 foreach (DataGridViewColumn col in SelectedColumns)
2331 col.Selected = false;
2332 foreach (DataGridViewRow row in SelectedRows)
2333 row.Selected = false;
2334 foreach (DataGridViewCell cell in SelectedCells)
2335 cell.Selected = false;
2338 public bool CommitEdit (DataGridViewDataErrorContexts context)
2340 if (currentCell != null && currentCell.IsInEditMode) {
2341 IDataGridViewEditingControl ctrl = EditingControl as IDataGridViewEditingControl;
2342 currentCell.Value = ctrl.GetEditingControlFormattedValue (DataGridViewDataErrorContexts.Commit);
2349 [MonoTODO ("Always includes partial columns")]
2350 public int DisplayedColumnCount (bool includePartialColumns)
2354 for (int i = first_col_index; i < Columns.Count; i++)
2355 if (Columns.ColumnDisplayIndexSortedArrayList[i].Displayed)
2363 public int DisplayedRowCount (bool includePartialRow)
2368 if (ColumnHeadersVisible)
2369 rowTop += ColumnHeadersHeight;
2371 for (int index = first_row_index; index < Rows.Count; index++) {
2372 DataGridViewRow row = GetRowInternal (index);
2373 if (rowTop + row.Height < ClientSize.Height) {
2375 rowTop += row.Height;
2377 if (includePartialRow)
2386 public bool EndEdit ()
2388 if (currentCell != null && currentCell.IsInEditMode) {
2389 if (EditingControl != null) {
2390 IDataGridViewEditingControl ctrl = EditingControl as IDataGridViewEditingControl;
2391 currentCell.Value = ctrl.GetEditingControlFormattedValue (DataGridViewDataErrorContexts.Commit);
2392 currentCell.SetIsInEditMode (false);
2393 currentCell.DetachEditingControl ();
2394 } else if (currentCell is IDataGridViewEditingCell) {
2395 currentCell.Value = (currentCell as IDataGridViewEditingCell).EditingCellFormattedValue;
2396 currentCell.SetIsInEditMode (false);
2399 new_row_commited = true;
2400 OnCellEndEdit (new DataGridViewCellEventArgs (currentCell.ColumnIndex, currentCell.RowIndex));
2407 [MonoTODO ("Does not use context parameter")]
2408 public bool EndEdit (DataGridViewDataErrorContexts context)
2413 public int GetCellCount (DataGridViewElementStates includeFilter) {
2415 foreach (DataGridViewRow row in rows) {
2416 foreach (DataGridViewCell cell in row.Cells) {
2417 if ((cell.State & includeFilter) != 0) {
2425 internal DataGridViewRow GetRowInternal (int rowIndex)
2427 return Rows.SharedRow (rowIndex);
2430 internal DataGridViewCell GetCellInternal (int colIndex, int rowIndex)
2432 return GetRowInternal (rowIndex).Cells.GetCellInternal (colIndex);
2435 public Rectangle GetCellDisplayRectangle (int columnIndex, int rowIndex, bool cutOverflow) {
2436 if (columnIndex < 0 || columnIndex >= columns.Count) {
2437 throw new ArgumentOutOfRangeException("Column index is out of range.");
2440 int x = 0, y = 0, w = 0, h = 0;
2445 if (ColumnHeadersVisible)
2446 y += ColumnHeadersHeight;
2448 if (RowHeadersVisible)
2449 x += RowHeadersWidth;
2451 List<DataGridViewColumn> cols = columns.ColumnDisplayIndexSortedArrayList;
2453 for (int i = first_col_index; i < cols.Count; i++) {
2454 if (!cols[i].Visible)
2457 if (cols[i].Index == columnIndex) {
2465 for (int i = first_row_index; i < Rows.Count; i++) {
2466 if (i == rowIndex) {
2467 h = rows [i].Height;
2471 y += rows [i].Height;
2474 return new Rectangle (x, y, w, h);
2477 public virtual DataObject GetClipboardContent () {
2479 if (clipboardCopyMode == DataGridViewClipboardCopyMode.Disable)
2480 throw new InvalidOperationException ("Generating Clipboard content is not supported when the ClipboardCopyMode property is Disable.");
2482 int start_row = int.MaxValue, end_row = int.MinValue;
2483 int start_col = int.MaxValue, end_col = int.MinValue;
2485 bool include_row_headers = false;
2486 bool include_col_headers = false;
2487 bool only_included_headers = false;
2488 bool headers_includable = false;
2490 switch (ClipboardCopyMode) {
2491 case DataGridViewClipboardCopyMode.EnableWithoutHeaderText:
2493 case DataGridViewClipboardCopyMode.EnableWithAutoHeaderText:
2494 // Headers are included if not selection mode is CellSelect, and any header is selected.
2495 headers_includable = selectionMode != DataGridViewSelectionMode.CellSelect;
2497 case DataGridViewClipboardCopyMode.EnableAlwaysIncludeHeaderText:
2498 include_col_headers = include_row_headers = true;
2502 BitArray included_rows = new BitArray (RowCount);
2503 BitArray included_cols = new BitArray (ColumnCount);
2505 // If there are any selected columns,
2506 // include the column headers (if headers are to be shown).
2507 if (headers_includable && !include_col_headers) {
2508 for (int c = 0; c < ColumnCount; c++) {
2509 if (Columns [c].Selected) {
2510 include_col_headers = true;
2516 // Find the smallest rectangle that encompasses all selected cells.
2517 for (int r = 0; r < RowCount; r++) {
2518 DataGridViewRow row = Rows [r];
2520 if (headers_includable && !include_row_headers && row.Selected) {
2521 include_row_headers = true;
2524 for (int c = 0; c < ColumnCount; c++) {
2525 DataGridViewCell cell = row.Cells [c];
2527 if (cell == null || !cell.Selected)
2530 included_cols [c] = true;
2531 included_rows [r] = true;
2533 start_row = Math.Min (start_row, r);
2534 start_col = Math.Min (start_col, c);
2535 end_row = Math.Max (end_row, r);
2536 end_col = Math.Max (end_col, c);
2540 // Mark rows/columns in between selected cells as included if the selection mode isn't FullHeaderSelect.
2541 switch (selectionMode){
2542 case DataGridViewSelectionMode.CellSelect:
2543 case DataGridViewSelectionMode.ColumnHeaderSelect:
2544 case DataGridViewSelectionMode.RowHeaderSelect:
2545 if (selectionMode != DataGridViewSelectionMode.ColumnHeaderSelect) {
2546 for (int r = start_row; r <= end_row; r++) {
2547 included_rows.Set (r, true);
2549 } else if (start_row <= end_row) {
2550 included_rows.SetAll (true);
2552 if (selectionMode != DataGridViewSelectionMode.RowHeaderSelect) {
2553 for (int c = start_col; c <= end_col; c++) {
2554 included_cols.Set (c, true);
2558 case DataGridViewSelectionMode.FullColumnSelect:
2559 case DataGridViewSelectionMode.FullRowSelect:
2560 only_included_headers = true;
2564 if (start_row > end_row)
2567 if (start_col > end_col)
2570 DataObject result = new DataObject ();
2572 System.Text.StringBuilder text_builder = new System.Text.StringBuilder ();
2573 System.Text.StringBuilder utext_builder = new System.Text.StringBuilder ();
2574 System.Text.StringBuilder html_builder = new System.Text.StringBuilder ();
2575 System.Text.StringBuilder csv_builder = new System.Text.StringBuilder ();
2577 // Loop through all rows and columns to create the content.
2578 // -1 is the header row/column.
2579 int first_row = start_row;
2580 int first_col = start_col;
2581 if (include_col_headers) {
2584 for (int r = first_row; r <= end_row; r++) {
2585 DataGridViewRow row = null;
2588 if (!included_rows [r])
2594 if (include_row_headers) {
2598 for (int c = first_col; c <= end_col; c++) {
2599 DataGridViewCell cell = null;
2601 if (c >= 0 && only_included_headers && !included_cols [c])
2606 cell = TopLeftHeaderCell;
2608 cell = Columns [c].HeaderCell;
2612 cell = row.HeaderCell;
2614 cell = row.Cells [c];
2618 string text, utext, html, csv;
2619 bool is_first_cell = (c == first_col);
2620 bool is_last_cell = (c == end_col);
2621 bool is_first_row = (r == first_row);
2622 bool is_last_row = (r == end_row);
2625 text = string.Empty;
2626 utext = string.Empty;
2627 html = string.Empty;
2630 text = cell.GetClipboardContentInternal (r, is_first_cell, is_last_cell, is_first_row, is_last_row, DataFormats.Text) as string;
2631 utext = cell.GetClipboardContentInternal (r, is_first_cell, is_last_cell, is_first_row, is_last_row, DataFormats.UnicodeText) as string;
2632 html = cell.GetClipboardContentInternal (r, is_first_cell, is_last_cell, is_first_row, is_last_row, DataFormats.Html) as string;
2633 csv = cell.GetClipboardContentInternal (r, is_first_cell, is_last_cell, is_first_row, is_last_row, DataFormats.CommaSeparatedValue) as string;
2636 text_builder.Append (text);
2637 utext_builder.Append (utext);
2638 html_builder.Append (html);
2639 csv_builder.Append (csv);
2641 if (c == -1) { // If we just did the row header, jump to the first column.
2646 if (r == -1) {// If we just did the column header, jump to the first row.
2652 // Html content always get the \r\n newline
2653 // It's valid html anyway, and it eases testing quite a bit
2654 // (since otherwise we'd have to change the start indices
2655 // in the added prologue/epilogue text)
2657 int fragment_end = 135 + html_builder.Length;
2658 int html_end = fragment_end + 36;
2661 "StartHTML:00000097{0}" +
2662 "EndHTML:{1:00000000}{0}" +
2663 "StartFragment:00000133{0}" +
2664 "EndFragment:{2:00000000}{0}" +
2667 "<!--StartFragment-->";
2669 html_start = string.Format (html_start, "\r\n", html_end, fragment_end);
2670 html_builder.Insert (0, html_start);
2671 html_builder.AppendFormat ("{0}<!--EndFragment-->{0}</BODY>{0}</HTML>", "\r\n");
2673 result.SetData (DataFormats.CommaSeparatedValue, false, csv_builder.ToString ());
2674 result.SetData (DataFormats.Html, false, html_builder.ToString ());
2675 result.SetData (DataFormats.UnicodeText, false, utext_builder.ToString ());
2676 result.SetData (DataFormats.Text, false, text_builder.ToString ());
2681 [MonoTODO ("Does not use cutOverflow parameter")]
2682 public Rectangle GetColumnDisplayRectangle (int columnIndex, bool cutOverflow)
2684 if (columnIndex < 0 || columnIndex > Columns.Count - 1)
2685 throw new ArgumentOutOfRangeException ("columnIndex");
2692 if (RowHeadersVisible)
2693 x += RowHeadersWidth;
2695 List<DataGridViewColumn> cols = columns.ColumnDisplayIndexSortedArrayList;
2697 for (int i = first_col_index; i < cols.Count; i++) {
2698 if (!cols[i].Visible)
2701 if (cols[i].Index == columnIndex) {
2709 return new Rectangle (x, 0, w, Height);
2712 [MonoTODO ("Does not use cutOverflow parameter")]
2713 public Rectangle GetRowDisplayRectangle (int rowIndex, bool cutOverflow)
2715 if (rowIndex < 0 || rowIndex > Rows.Count - 1)
2716 throw new ArgumentOutOfRangeException ("rowIndex");
2723 if (ColumnHeadersVisible)
2724 y += ColumnHeadersHeight;
2726 for (int i = first_row_index; i < Rows.Count; i++) {
2727 if (i == rowIndex) {
2732 y += rows[i].Height;
2735 return new Rectangle (0, y, Width, h);
2738 public HitTestInfo HitTest (int x, int y) {
2739 ///////////////////////////////////////////////////////
2740 //Console.WriteLine ("HitTest ({0}, {1})", x, y);
2741 bool isInColHeader = columnHeadersVisible && y >= 0 && y <= ColumnHeadersHeight;
2742 bool isInRowHeader = rowHeadersVisible && x >= 0 && x <= RowHeadersWidth;
2745 if (isInColHeader && isInRowHeader)
2746 return new HitTestInfo (-1, x, -1, y, DataGridViewHitTestType.TopLeftHeader);
2748 // HorizontalScrollBar
2749 if (horizontalScrollBar.Visible && horizontalScrollBar.Bounds.Contains (x, y))
2750 return new HitTestInfo (-1, x, -1, y, DataGridViewHitTestType.HorizontalScrollBar);
2752 // VerticalScrollBar
2753 if (verticalScrollBar.Visible && verticalScrollBar.Bounds.Contains (x, y))
2754 return new HitTestInfo (-1, x, -1, y, DataGridViewHitTestType.VerticalScrollBar);
2756 // The little box in the bottom right if both scrollbars are shown is None
2757 if (verticalScrollBar.Visible && horizontalScrollBar.Visible)
2758 if (new Rectangle (verticalScrollBar.Left, horizontalScrollBar.Top, verticalScrollBar.Width, horizontalScrollBar.Height).Contains (x, y))
2759 return new HitTestInfo (-1, x, -1, y, DataGridViewHitTestType.None);
2764 int top = columnHeadersVisible ? columnHeadersHeight : 0;
2766 for (int i = first_row_index; i < Rows.Count; i++) {
2767 DataGridViewRow row = Rows[i];
2769 if (y > top && y <= (top + row.Height)) {
2777 int left = rowHeadersVisible ? RowHeadersWidth : 0;
2779 List<DataGridViewColumn> cols = columns.ColumnDisplayIndexSortedArrayList;
2781 for (int i = first_col_index; i < cols.Count; i++) {
2782 if (!cols[i].Visible)
2785 if (x > left && x <= (left + cols[i].Width)) {
2786 colindex = cols[i].Index;
2790 left += cols[i].Width;
2793 if (colindex >= 0 && rowindex >= 0)
2794 return new HitTestInfo (colindex, x, rowindex, y, DataGridViewHitTestType.Cell);
2796 if (isInColHeader && colindex > -1)
2797 return new HitTestInfo (colindex, x, rowindex, y, DataGridViewHitTestType.ColumnHeader);
2799 if (isInRowHeader && rowindex > -1)
2800 return new HitTestInfo (colindex, x, rowindex, y, DataGridViewHitTestType.RowHeader);
2802 return new HitTestInfo (-1, x, -1, y, DataGridViewHitTestType.None);
2805 [MonoTODO ("Invalidates whole grid")]
2806 public void InvalidateCell (DataGridViewCell dataGridViewCell)
2808 if (dataGridViewCell == null)
2809 throw new ArgumentNullException ("Cell is null");
2811 if (dataGridViewCell.DataGridView != this)
2812 throw new ArgumentException ("The specified cell does not belong to this DataGridView.");
2814 InvalidateCell (dataGridViewCell.ColumnIndex, dataGridViewCell.RowIndex);
2817 [MonoTODO ("Invalidates whole grid")]
2818 public void InvalidateCell (int columnIndex, int rowIndex)
2820 if (columnIndex < 0 || columnIndex >= columns.Count)
2821 throw new ArgumentOutOfRangeException ("Column index is out of range.");
2823 if (rowIndex < 0 || rowIndex >= rows.Count)
2824 throw new ArgumentOutOfRangeException ("Row index is out of range.");
2826 Invalidate (GetCellDisplayRectangle (columnIndex, rowIndex, true));
2829 [MonoTODO ("Invalidates whole grid")]
2830 public void InvalidateColumn (int columnIndex)
2832 if (columnIndex < 0 || columnIndex >= columns.Count)
2833 throw new ArgumentOutOfRangeException ("Column index is out of range.");
2835 Invalidate (GetColumnDisplayRectangle (columnIndex, true));
2838 [MonoTODO ("Invalidates whole grid")]
2839 public void InvalidateRow (int rowIndex)
2841 if (rowIndex < 0 || rowIndex >= rows.Count)
2842 throw new ArgumentOutOfRangeException ("Row index is out of range.");
2844 Invalidate (GetRowDisplayRectangle (rowIndex, true));
2847 public virtual void NotifyCurrentCellDirty (bool dirty) {
2848 if (currentCell != null)
2849 InvalidateCell (currentCell);
2852 public bool RefreshEdit ()
2854 if (IsCurrentCellInEditMode) {
2855 currentCell.InitializeEditingControl (currentCell.RowIndex, currentCell.FormattedValue, currentCell.InheritedStyle);
2862 [EditorBrowsable (EditorBrowsableState.Never)]
2863 public override void ResetText ()
2865 Text = string.Empty;
2868 public void SelectAll () {
2869 switch (selectionMode) {
2870 case DataGridViewSelectionMode.FullRowSelect:
2871 foreach (DataGridViewRow row in rows) {
2872 (row as DataGridViewBand).Selected = true;
2875 case DataGridViewSelectionMode.FullColumnSelect:
2876 foreach (DataGridViewColumn col in columns) {
2877 (col as DataGridViewBand).Selected = true;
2881 foreach (DataGridViewRow row in rows) {
2882 foreach (DataGridViewCell cell in row.Cells) {
2883 cell.Selected = true;
2892 public virtual void Sort (IComparer comparer)
2894 if (comparer == null)
2895 throw new ArgumentNullException ("comparer");
2896 if (VirtualMode || DataSource != null)
2897 throw new InvalidOperationException ();
2899 if (SortedColumn != null)
2900 SortedColumn.HeaderCell.SortGlyphDirection = SortOrder.None;
2904 Rows.Sort (comparer);
2906 sortedColumn = null;
2907 sortOrder = SortOrder.None;
2913 OnSorted (EventArgs.Empty);
2916 public virtual void Sort (DataGridViewColumn dataGridViewColumn, ListSortDirection direction)
2918 if (dataGridViewColumn == null)
2919 throw new ArgumentNullException ("dataGridViewColumn");
2920 if (dataGridViewColumn.DataGridView != this)
2921 throw new ArgumentException ("dataGridViewColumn");
2926 if (SortedColumn != null)
2927 SortedColumn.HeaderCell.SortGlyphDirection = SortOrder.None;
2929 sortedColumn = dataGridViewColumn;
2930 sortOrder = direction == ListSortDirection.Ascending ? SortOrder.Ascending : SortOrder.Descending;
2932 if (Rows.Count == 0)
2935 IBindingList bindingList = DataSource as IBindingList;
2936 if (dataGridViewColumn.IsDataBound) {
2937 if (bindingList != null && bindingList.SupportsSorting) {
2938 CurrencyManager currencyManager = (CurrencyManager) this.BindingContext[DataSource];
2939 bindingList.ApplySort (currencyManager.GetItemProperties()[dataGridViewColumn.DataPropertyName], direction);
2940 dataGridViewColumn.HeaderCell.SortGlyphDirection = sortOrder;
2943 // Figure out if this is a numeric sort or text sort
2944 bool is_numeric = true;
2947 foreach (DataGridViewRow row in Rows) {
2948 object val = row.Cells[dataGridViewColumn.Index].Value;
2950 if (val != null && !double.TryParse (val.ToString (), out n)) {
2956 ColumnSorter sorter = new ColumnSorter (dataGridViewColumn, direction, is_numeric);
2958 dataGridViewColumn.HeaderCell.SortGlyphDirection = sortOrder;
2962 OnSorted (EventArgs.Empty);
2965 public void UpdateCellErrorText (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 UpdateCellValue (int columnIndex, int rowIndex)
2977 if (columnIndex < 0 || columnIndex > Columns.Count - 1)
2978 throw new ArgumentOutOfRangeException ("columnIndex");
2979 if (rowIndex < 0 || rowIndex > Rows.Count - 1)
2980 throw new ArgumentOutOfRangeException ("rowIndex");
2982 InvalidateCell (columnIndex, rowIndex);
2985 public void UpdateRowErrorText (int rowIndex)
2987 if (rowIndex < 0 || rowIndex > Rows.Count - 1)
2988 throw new ArgumentOutOfRangeException ("rowIndex");
2990 InvalidateRow (rowIndex);
2993 public void UpdateRowErrorText (int rowIndexStart, int rowIndexEnd)
2995 if (rowIndexStart < 0 || rowIndexStart > Rows.Count - 1)
2996 throw new ArgumentOutOfRangeException ("rowIndexStart");
2997 if (rowIndexEnd < 0 || rowIndexEnd > Rows.Count - 1)
2998 throw new ArgumentOutOfRangeException ("rowIndexEnd");
2999 if (rowIndexEnd < rowIndexStart)
3000 throw new ArgumentOutOfRangeException ("rowIndexEnd", "rowIndexEnd must be greater than rowIndexStart");
3002 for (int i = rowIndexStart; i <= rowIndexEnd; i++)
3006 public void UpdateRowHeightInfo (int rowIndex, bool updateToEnd) {
3007 throw new NotImplementedException();
3010 protected override bool CanEnableIme {
3012 if (CurrentCell != null && CurrentCell.EditType != null)
3019 protected override Size DefaultSize {
3020 get { return new Size (240, 150); }
3023 protected ScrollBar HorizontalScrollBar {
3024 get { return horizontalScrollBar; }
3027 protected ScrollBar VerticalScrollBar {
3028 get { return verticalScrollBar; }
3031 protected virtual void AccessibilityNotifyCurrentCellChanged (Point cellAddress)
3033 throw new NotImplementedException ();
3036 [MonoTODO ("Does not use fixedHeight parameter")]
3037 protected void AutoResizeColumn (int columnIndex, DataGridViewAutoSizeColumnMode autoSizeColumnMode, bool fixedHeight)
3039 AutoResizeColumn (columnIndex, autoSizeColumnMode);
3042 [MonoTODO ("Does not use fixedRowHeadersWidth or fixedColumnsWidth parameters")]
3043 protected void AutoResizeColumnHeadersHeight (bool fixedRowHeadersWidth, bool fixedColumnsWidth)
3045 AutoResizeColumnHeadersHeight ();
3048 [MonoTODO ("Does not use columnIndex or fixedRowHeadersWidth or fixedColumnsWidth parameters")]
3049 protected void AutoResizeColumnHeadersHeight (int columnIndex, bool fixedRowHeadersWidth, bool fixedColumnWidth)
3051 AutoResizeColumnHeadersHeight (columnIndex);
3054 protected void AutoResizeColumns (DataGridViewAutoSizeColumnsMode autoSizeColumnsMode, bool fixedHeight) {
3055 for (int i = 0; i < Columns.Count; i++) {
3056 AutoResizeColumn (i, (DataGridViewAutoSizeColumnMode) autoSizeColumnsMode, fixedHeight);
3060 [MonoTODO ("Does not use fixedWidth parameter")]
3061 protected void AutoResizeRow (int rowIndex, DataGridViewAutoSizeRowMode autoSizeRowMode, bool fixedWidth)
3063 if (autoSizeRowMode == DataGridViewAutoSizeRowMode.RowHeader && !rowHeadersVisible)
3064 throw new InvalidOperationException ("row headers are not visible");
3065 if (rowIndex < 0 || rowIndex > Rows.Count - 1)
3066 throw new ArgumentOutOfRangeException ("rowIndex");
3068 DataGridViewRow row = GetRowInternal (rowIndex);
3070 int new_height = row.GetPreferredHeight (rowIndex, autoSizeRowMode, true);
3072 if (row.Height != new_height)
3073 row.SetAutoSizeHeight (new_height);
3076 [MonoTODO ("Does not use fixedColumnHeadersHeight or fixedRowsHeight parameter")]
3077 protected void AutoResizeRowHeadersWidth (DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode, bool fixedColumnHeadersHeight, bool fixedRowsHeight)
3079 AutoResizeRowHeadersWidth (rowHeadersWidthSizeMode);
3082 [MonoTODO ("Does not use rowIndex or fixedColumnHeadersHeight or fixedRowsHeight parameter")]
3083 protected void AutoResizeRowHeadersWidth (int rowIndex, DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode, bool fixedColumnHeadersHeight, bool fixedRowHeight)
3085 AutoResizeRowHeadersWidth (rowHeadersWidthSizeMode);
3088 [MonoTODO ("Does not use fixedWidth parameter")]
3089 protected void AutoResizeRows (DataGridViewAutoSizeRowsMode autoSizeRowsMode, bool fixedWidth)
3091 if (autoSizeRowsMode == DataGridViewAutoSizeRowsMode.None)
3094 bool displayed_only = false;
3095 DataGridViewAutoSizeRowMode mode = DataGridViewAutoSizeRowMode.AllCells;
3097 switch (autoSizeRowsMode) {
3098 case DataGridViewAutoSizeRowsMode.AllHeaders:
3099 mode = DataGridViewAutoSizeRowMode.RowHeader;
3101 case DataGridViewAutoSizeRowsMode.AllCellsExceptHeaders:
3102 mode = DataGridViewAutoSizeRowMode.AllCellsExceptHeader;
3104 case DataGridViewAutoSizeRowsMode.AllCells:
3105 mode = DataGridViewAutoSizeRowMode.AllCells;
3107 case DataGridViewAutoSizeRowsMode.DisplayedHeaders:
3108 mode = DataGridViewAutoSizeRowMode.RowHeader;
3109 displayed_only = true;
3111 case DataGridViewAutoSizeRowsMode.DisplayedCellsExceptHeaders:
3112 mode = DataGridViewAutoSizeRowMode.AllCellsExceptHeader;
3113 displayed_only = true;
3115 case DataGridViewAutoSizeRowsMode.DisplayedCells:
3116 mode = DataGridViewAutoSizeRowMode.AllCells;
3117 displayed_only = true;
3121 foreach (DataGridViewRow row in Rows) {
3122 if (!displayed_only || row.Displayed) {
3123 int new_height = row.GetPreferredHeight (row.Index, mode, fixedWidth);
3125 if (row.Height != new_height)
3126 row.SetAutoSizeHeight (new_height);
3131 [MonoTODO ("Does not use fixedMode parameter")]
3132 protected void AutoResizeRows (int rowIndexStart, int rowsCount, DataGridViewAutoSizeRowMode autoSizeRowMode, bool fixedWidth)
3134 for (int i = rowIndexStart; i < rowIndexStart + rowsCount; i++)
3135 AutoResizeRow (i, autoSizeRowMode, fixedWidth);
3138 protected void ClearSelection (int columnIndexException, int rowIndexException, bool selectExceptionElement) {
3139 if (columnIndexException >= columns.Count) {
3140 throw new ArgumentOutOfRangeException("ColumnIndexException is greater than the highest column index.");
3142 if (selectionMode == DataGridViewSelectionMode.FullRowSelect) {
3143 if (columnIndexException < -1) {
3144 throw new ArgumentOutOfRangeException("ColumnIndexException is less than -1.");
3148 if (columnIndexException < 0) {
3149 throw new ArgumentOutOfRangeException("ColumnIndexException is less than 0.");
3152 if (rowIndexException >= rows.Count) {
3153 throw new ArgumentOutOfRangeException("RowIndexException is greater than the highest row index.");
3155 if (selectionMode == DataGridViewSelectionMode.FullColumnSelect) {
3156 if (rowIndexException < -1) {
3157 throw new ArgumentOutOfRangeException("RowIndexException is less than -1.");
3161 if (rowIndexException < 0) {
3162 throw new ArgumentOutOfRangeException("RowIndexException is less than 0.");
3165 switch (selectionMode) {
3166 case DataGridViewSelectionMode.FullRowSelect:
3167 foreach (DataGridViewRow row in rows) {
3168 if (selectExceptionElement && row.Index == rowIndexException) {
3171 SetSelectedRowCore (row.Index, false);
3174 case DataGridViewSelectionMode.FullColumnSelect:
3175 foreach (DataGridViewColumn col in columns) {
3176 if (selectExceptionElement && col.Index == columnIndexException) {
3179 SetSelectedColumnCore (col.Index, false);
3183 foreach (DataGridViewCell cell in SelectedCells) {
3184 if (selectExceptionElement && cell.RowIndex == rowIndexException && cell.ColumnIndex == columnIndexException) {
3187 SetSelectedCellCore (cell.ColumnIndex, cell.RowIndex, false);
3193 protected override AccessibleObject CreateAccessibilityInstance ()
3195 return new DataGridViewAccessibleObject(this);
3198 [EditorBrowsable (EditorBrowsableState.Advanced)]
3199 protected virtual DataGridViewColumnCollection CreateColumnsInstance ()
3201 return new DataGridViewColumnCollection(this);
3204 protected override Control.ControlCollection CreateControlsInstance ()
3206 return new DataGridViewControlCollection (this);
3209 [EditorBrowsable (EditorBrowsableState.Advanced)]
3210 protected virtual DataGridViewRowCollection CreateRowsInstance ()
3212 return new DataGridViewRowCollection(this);
3215 protected override void Dispose (bool disposing) {
3218 protected override AccessibleObject GetAccessibilityObjectById (int objectId)
3220 throw new NotImplementedException();
3223 protected override bool IsInputChar (char charCode)
3228 protected override bool IsInputKey (Keys keyData)
3230 // Don't look at the modifiers
3231 keyData = keyData & ~Keys.Modifiers;
3253 protected virtual void OnAllowUserToAddRowsChanged (EventArgs e)
3255 EventHandler eh = (EventHandler)(Events [AllowUserToAddRowsChangedEvent]);
3260 protected virtual void OnAllowUserToDeleteRowsChanged (EventArgs e)
3262 EventHandler eh = (EventHandler)(Events [AllowUserToDeleteRowsChangedEvent]);
3267 protected virtual void OnAllowUserToOrderColumnsChanged (EventArgs e)
3269 EventHandler eh = (EventHandler)(Events [AllowUserToOrderColumnsChangedEvent]);
3274 protected virtual void OnAllowUserToResizeColumnsChanged (EventArgs e)
3276 EventHandler eh = (EventHandler)(Events [AllowUserToResizeColumnsChangedEvent]);
3281 protected virtual void OnAllowUserToResizeRowsChanged (EventArgs e)
3283 EventHandler eh = (EventHandler)(Events [AllowUserToResizeRowsChangedEvent]);
3288 protected virtual void OnAlternatingRowsDefaultCellStyleChanged (EventArgs e)
3290 EventHandler eh = (EventHandler)(Events [AlternatingRowsDefaultCellStyleChangedEvent]);
3295 protected virtual void OnAutoGenerateColumnsChanged (EventArgs e)
3297 EventHandler eh = (EventHandler)(Events [AutoGenerateColumnsChangedEvent]);
3302 protected internal virtual void OnAutoSizeColumnModeChanged (DataGridViewAutoSizeColumnModeEventArgs e)
3304 DataGridViewAutoSizeColumnModeEventHandler eh = (DataGridViewAutoSizeColumnModeEventHandler)(Events [AutoSizeColumnModeChangedEvent]);
3309 protected virtual void OnAutoSizeColumnsModeChanged (DataGridViewAutoSizeColumnsModeEventArgs e)
3311 DataGridViewAutoSizeColumnsModeEventHandler eh = (DataGridViewAutoSizeColumnsModeEventHandler)(Events [AutoSizeColumnsModeChangedEvent]);
3316 protected virtual void OnAutoSizeRowsModeChanged (DataGridViewAutoSizeModeEventArgs e)
3318 DataGridViewAutoSizeModeEventHandler eh = (DataGridViewAutoSizeModeEventHandler)(Events [AutoSizeRowsModeChangedEvent]);
3323 protected virtual void OnBackgroundColorChanged (EventArgs e)
3325 EventHandler eh = (EventHandler)(Events [BackgroundColorChangedEvent]);
3330 protected override void OnBindingContextChanged (EventArgs e)
3332 base.OnBindingContextChanged(e);
3335 protected virtual void OnBorderStyleChanged (EventArgs e)
3337 EventHandler eh = (EventHandler)(Events [BorderStyleChangedEvent]);
3342 protected virtual void OnCancelRowEdit (QuestionEventArgs e) {
3343 QuestionEventHandler eh = (QuestionEventHandler)(Events [CancelRowEditEvent]);
3348 protected virtual void OnCellBeginEdit (DataGridViewCellCancelEventArgs e)
3350 DataGridViewCellCancelEventHandler eh = (DataGridViewCellCancelEventHandler)(Events [CellBeginEditEvent]);
3355 protected virtual void OnCellBorderStyleChanged (EventArgs e)
3357 EventHandler eh = (EventHandler)(Events [CellBorderStyleChangedEvent]);
3362 protected virtual void OnCellClick (DataGridViewCellEventArgs e)
3364 DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3366 cell.OnClickInternal (e);
3368 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellClickEvent]);
3373 protected virtual void OnCellContentClick (DataGridViewCellEventArgs e)
3375 DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3377 cell.OnContentClickInternal (e);
3379 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellContentClickEvent]);
3384 protected virtual void OnCellContentDoubleClick (DataGridViewCellEventArgs e)
3386 DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3388 cell.OnContentDoubleClickInternal (e);
3390 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellContentDoubleClickEvent]);
3395 protected virtual void OnCellContextMenuStripChanged (DataGridViewCellEventArgs e)
3397 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellContextMenuStripChangedEvent]);
3402 protected virtual void OnCellContextMenuStripNeeded (DataGridViewCellContextMenuStripNeededEventArgs e)
3404 DataGridViewCellContextMenuStripNeededEventHandler eh = (DataGridViewCellContextMenuStripNeededEventHandler)(Events [CellContextMenuStripNeededEvent]);
3409 protected virtual void OnCellDoubleClick (DataGridViewCellEventArgs e)
3411 DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3413 cell.OnDoubleClickInternal (e);
3414 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellDoubleClickEvent]);
3419 protected virtual void OnCellEndEdit (DataGridViewCellEventArgs e)
3421 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellEndEditEvent]);
3426 protected virtual void OnCellEnter (DataGridViewCellEventArgs e)
3428 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellEnterEvent]);
3433 protected internal virtual void OnCellErrorTextChanged (DataGridViewCellEventArgs e)
3435 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellErrorTextChangedEvent]);
3440 protected virtual void OnCellErrorTextNeeded (DataGridViewCellErrorTextNeededEventArgs e)
3442 DataGridViewCellErrorTextNeededEventHandler eh = (DataGridViewCellErrorTextNeededEventHandler)(Events [CellErrorTextNeededEvent]);
3447 internal void OnCellFormattingInternal (DataGridViewCellFormattingEventArgs e)
3449 OnCellFormatting (e);
3452 protected virtual void OnCellFormatting (DataGridViewCellFormattingEventArgs e)
3454 DataGridViewCellFormattingEventHandler eh = (DataGridViewCellFormattingEventHandler)(Events [CellFormattingEvent]);
3459 protected virtual void OnCellLeave (DataGridViewCellEventArgs e)
3461 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellLeaveEvent]);
3466 protected virtual void OnCellMouseClick (DataGridViewCellMouseEventArgs e)
3468 DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3470 cell.OnMouseClickInternal (e);
3472 DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [CellMouseClickEvent]);
3477 protected virtual void OnCellMouseDoubleClick (DataGridViewCellMouseEventArgs e)
3479 DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3481 cell.OnMouseDoubleClickInternal (e);
3483 DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [CellMouseDoubleClickEvent]);
3488 protected virtual void OnCellMouseDown (DataGridViewCellMouseEventArgs e)
3491 DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3493 cell.OnMouseDownInternal (e);
3495 DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [CellMouseDownEvent]);
3500 protected virtual void OnCellMouseEnter (DataGridViewCellEventArgs e)
3502 DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3504 cell.OnMouseEnterInternal (e.RowIndex);
3506 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellMouseEnterEvent]);
3511 protected virtual void OnCellMouseLeave (DataGridViewCellEventArgs e)
3513 DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3515 cell.OnMouseLeaveInternal (e.RowIndex);
3517 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellMouseLeaveEvent]);
3522 protected virtual void OnCellMouseMove (DataGridViewCellMouseEventArgs e)
3524 DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3526 cell.OnMouseMoveInternal (e);
3528 DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [CellMouseMoveEvent]);
3533 protected virtual void OnCellMouseUp (DataGridViewCellMouseEventArgs e)
3535 DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3537 cell.OnMouseUpInternal (e);
3539 DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [CellMouseUpEvent]);
3544 internal void OnCellPaintingInternal (DataGridViewCellPaintingEventArgs e)
3549 protected virtual void OnCellPainting (DataGridViewCellPaintingEventArgs e)
3551 DataGridViewCellPaintingEventHandler eh = (DataGridViewCellPaintingEventHandler)(Events [CellPaintingEvent]);
3556 protected internal virtual void OnCellParsing (DataGridViewCellParsingEventArgs e)
3558 DataGridViewCellParsingEventHandler eh = (DataGridViewCellParsingEventHandler)(Events [CellParsingEvent]);
3563 internal void OnCellStateChangedInternal (DataGridViewCellStateChangedEventArgs e) {
3564 this.OnCellStateChanged (e);
3567 protected virtual void OnCellStateChanged (DataGridViewCellStateChangedEventArgs e)
3569 DataGridViewCellStateChangedEventHandler eh = (DataGridViewCellStateChangedEventHandler)(Events [CellStateChangedEvent]);
3574 protected virtual void OnCellStyleChanged (DataGridViewCellEventArgs e)
3576 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellStyleChangedEvent]);
3581 protected virtual void OnCellStyleContentChanged (DataGridViewCellStyleContentChangedEventArgs e) {
3582 DataGridViewCellStyleContentChangedEventHandler eh = (DataGridViewCellStyleContentChangedEventHandler)(Events [CellStyleContentChangedEvent]);
3587 protected virtual void OnCellToolTipTextChanged (DataGridViewCellEventArgs e) {
3588 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellToolTipTextChangedEvent]);
3593 protected virtual void OnCellToolTipTextNeeded (DataGridViewCellToolTipTextNeededEventArgs e)
3595 DataGridViewCellToolTipTextNeededEventHandler eh = (DataGridViewCellToolTipTextNeededEventHandler)(Events [CellToolTipTextNeededEvent]);
3600 protected virtual void OnCellValidated (DataGridViewCellEventArgs e)
3602 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellValidatedEvent]);
3607 protected virtual void OnCellValidating (DataGridViewCellValidatingEventArgs e)
3609 DataGridViewCellValidatingEventHandler eh = (DataGridViewCellValidatingEventHandler)(Events [CellValidatingEvent]);
3614 protected virtual void OnCellValueChanged (DataGridViewCellEventArgs e)
3616 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellValueChangedEvent]);
3621 protected internal virtual void OnCellValueNeeded (DataGridViewCellValueEventArgs e)
3623 DataGridViewCellValueEventHandler eh = (DataGridViewCellValueEventHandler)(Events [CellValueNeededEvent]);
3628 protected virtual void OnCellValuePushed (DataGridViewCellValueEventArgs e)
3630 DataGridViewCellValueEventHandler eh = (DataGridViewCellValueEventHandler)(Events [CellValuePushedEvent]);
3635 internal void OnColumnAddedInternal (DataGridViewColumnEventArgs e)
3637 if (e.Column.CellTemplate != null) {
3638 foreach (DataGridViewRow row in Rows)
3639 row.Cells.Add ((DataGridViewCell)e.Column.CellTemplate.Clone ());
3642 AutoResizeColumnsInternal ();
3644 PrepareEditingRow (false, true);
3647 protected virtual void OnColumnAdded (DataGridViewColumnEventArgs e)
3649 DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnAddedEvent]);
3654 protected internal virtual void OnColumnContextMenuStripChanged (DataGridViewColumnEventArgs e)
3656 DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnContextMenuStripChangedEvent]);
3661 protected internal virtual void OnColumnDataPropertyNameChanged (DataGridViewColumnEventArgs e)
3663 DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnDataPropertyNameChangedEvent]);
3668 protected internal virtual void OnColumnDefaultCellStyleChanged (DataGridViewColumnEventArgs e)
3670 DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnDefaultCellStyleChangedEvent]);
3675 protected internal virtual void OnColumnDisplayIndexChanged (DataGridViewColumnEventArgs e)
3677 DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnDisplayIndexChangedEvent]);
3682 protected virtual void OnColumnDividerDoubleClick (DataGridViewColumnDividerDoubleClickEventArgs e)
3684 DataGridViewColumnDividerDoubleClickEventHandler eh = (DataGridViewColumnDividerDoubleClickEventHandler)(Events [ColumnDividerDoubleClickEvent]);
3689 protected internal virtual void OnColumnDividerWidthChanged (DataGridViewColumnEventArgs e)
3691 DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnDividerWidthChangedEvent]);
3696 protected internal virtual void OnColumnHeaderCellChanged (DataGridViewColumnEventArgs e)
3698 DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnHeaderCellChangedEvent]);
3703 protected virtual void OnColumnHeaderMouseClick (DataGridViewCellMouseEventArgs e)
3705 DataGridViewColumn col = Columns[e.ColumnIndex];
3707 if (col.SortMode == DataGridViewColumnSortMode.Automatic) {
3708 ListSortDirection new_order;
3710 // Always use ascending unless we are clicking on a
3711 // column that is already sorted ascending.
3712 if (SortedColumn != col || sortOrder != SortOrder.Ascending)
3713 new_order = ListSortDirection.Ascending;
3715 new_order = ListSortDirection.Descending;
3717 Sort (col, new_order);
3720 DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [ColumnHeaderMouseClickEvent]);
3725 protected virtual void OnColumnHeaderMouseDoubleClick (DataGridViewCellMouseEventArgs e)
3727 DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [ColumnHeaderMouseDoubleClickEvent]);
3732 protected virtual void OnColumnHeadersBorderStyleChanged (EventArgs e)
3734 EventHandler eh = (EventHandler)(Events [ColumnHeadersBorderStyleChangedEvent]);
3739 protected virtual void OnColumnHeadersDefaultCellStyleChanged (EventArgs e)
3741 EventHandler eh = (EventHandler)(Events [ColumnHeadersDefaultCellStyleChangedEvent]);
3746 protected virtual void OnColumnHeadersHeightChanged (EventArgs e)
3748 EventHandler eh = (EventHandler)(Events [ColumnHeadersHeightChangedEvent]);
3753 protected virtual void OnColumnHeadersHeightSizeModeChanged (DataGridViewAutoSizeModeEventArgs e)
3755 DataGridViewAutoSizeModeEventHandler eh = (DataGridViewAutoSizeModeEventHandler)(Events [ColumnHeadersHeightSizeModeChangedEvent]);
3760 protected internal virtual void OnColumnMinimumWidthChanged (DataGridViewColumnEventArgs e)
3762 DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnMinimumWidthChangedEvent]);
3767 protected internal virtual void OnColumnNameChanged (DataGridViewColumnEventArgs e)
3769 DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnNameChangedEvent]);
3774 internal void OnColumnRemovedInternal (DataGridViewColumnEventArgs e)
3776 if (e.Column.CellTemplate != null) {
3777 int index = e.Column.Index;
3779 foreach (DataGridViewRow row in Rows)
3780 row.Cells.RemoveAt (index);
3783 AutoResizeColumnsInternal ();
3784 OnColumnRemoved (e);
3785 PrepareEditingRow (false, true);
3788 protected virtual void OnColumnRemoved (DataGridViewColumnEventArgs e)
3790 DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnRemovedEvent]);
3795 protected internal virtual void OnColumnSortModeChanged (DataGridViewColumnEventArgs e)
3797 DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnSortModeChangedEvent]);
3802 protected internal virtual void OnColumnStateChanged (DataGridViewColumnStateChangedEventArgs e)
3804 DataGridViewColumnStateChangedEventHandler eh = (DataGridViewColumnStateChangedEventHandler)(Events [ColumnStateChangedEvent]);
3809 protected internal virtual void OnColumnToolTipTextChanged (DataGridViewColumnEventArgs e)
3811 DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnToolTipTextChangedEvent]);
3816 protected internal virtual void OnColumnWidthChanged (DataGridViewColumnEventArgs e)
3818 DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnWidthChangedEvent]);
3823 protected virtual void OnCurrentCellChanged (EventArgs e)
3825 EventHandler eh = (EventHandler)(Events [CurrentCellChangedEvent]);
3830 protected virtual void OnCurrentCellDirtyStateChanged (EventArgs e)
3832 EventHandler eh = (EventHandler)(Events [CurrentCellDirtyStateChangedEvent]);
3837 protected override void OnCursorChanged (EventArgs e)
3839 base.OnCursorChanged (e);
3842 protected virtual void OnDataBindingComplete (DataGridViewBindingCompleteEventArgs e)
3844 DataGridViewBindingCompleteEventHandler eh = (DataGridViewBindingCompleteEventHandler)(Events [DataBindingCompleteEvent]);
3849 protected virtual void OnDataError (bool displayErrorDialogIfNoHandler, DataGridViewDataErrorEventArgs e)
3851 DataGridViewDataErrorEventHandler eh = (DataGridViewDataErrorEventHandler)(Events [DataErrorEvent]);
3855 else if (displayErrorDialogIfNoHandler)
3856 MessageBox.Show (e.ToString ());
3858 protected virtual void OnDataMemberChanged (EventArgs e) {
3859 EventHandler eh = (EventHandler)(Events [DataMemberChangedEvent]);
3864 protected virtual void OnDataSourceChanged (EventArgs e) {
3865 EventHandler eh = (EventHandler)(Events [DataSourceChangedEvent]);
3870 protected virtual void OnDefaultCellStyleChanged (EventArgs e) {
3871 EventHandler eh = (EventHandler)(Events [DefaultCellStyleChangedEvent]);
3876 protected virtual void OnDefaultValuesNeeded (DataGridViewRowEventArgs e) {
3877 DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [DefaultValuesNeededEvent]);
3882 protected override void OnDoubleClick (EventArgs e) {
3883 base.OnDoubleClick(e);
3886 protected virtual void OnEditingControlShowing (DataGridViewEditingControlShowingEventArgs e) {
3887 DataGridViewEditingControlShowingEventHandler eh = (DataGridViewEditingControlShowingEventHandler)(Events [EditingControlShowingEvent]);
3892 protected virtual void OnEditModeChanged (EventArgs e)
3894 EventHandler eh = (EventHandler)(Events [EditModeChangedEvent]);
3899 protected override void OnEnabledChanged (EventArgs e)
3901 base.OnEnabledChanged(e);
3904 protected override void OnEnter (EventArgs e )
3909 protected override void OnGotFocus(EventArgs e)
3911 base.OnGotFocus (e);
3913 // To add focus rectangle if needed
3914 if (currentCell != null && ShowFocusCues)
3915 InvalidateCell (currentCell);
3918 protected override void OnFontChanged (EventArgs e)
3920 base.OnFontChanged(e);
3923 protected override void OnForeColorChanged (EventArgs e)
3925 base.OnForeColorChanged(e);
3928 protected virtual void OnGridColorChanged (EventArgs e)
3930 EventHandler eh = (EventHandler)(Events [GridColorChangedEvent]);
3935 protected override void OnHandleCreated (EventArgs e)
3937 base.OnHandleCreated(e);
3939 if (CurrentCell == null && Rows.Count > 0 && Columns.Count > 0)
3940 MoveCurrentCell (ColumnDisplayIndexToIndex (0), 0, true, false, false, false);
3943 protected override void OnHandleDestroyed(EventArgs e)
3945 base.OnHandleDestroyed (e);
3948 [EditorBrowsable (EditorBrowsableState.Advanced)]
3949 protected override void OnKeyDown (KeyEventArgs e)
3953 e.Handled = ProcessDataGridViewKey (e);
3956 [EditorBrowsable (EditorBrowsableState.Advanced)]
3957 protected override void OnKeyPress (KeyPressEventArgs e)
3962 [EditorBrowsable (EditorBrowsableState.Advanced)]
3963 protected override void OnKeyUp (KeyEventArgs e)
3968 protected override void OnLayout (LayoutEventArgs e)
3970 if (horizontalScrollBar.Visible && verticalScrollBar.Visible) {
3971 horizontalScrollBar.Bounds = new Rectangle (BorderWidth, Height - BorderWidth - horizontalScrollBar.Height, Width - (2 * BorderWidth) - verticalScrollBar.Width, horizontalScrollBar.Height);
3972 verticalScrollBar.Bounds = new Rectangle (Width - BorderWidth - verticalScrollBar.Width, BorderWidth, verticalScrollBar.Width, Height - (2 * BorderWidth) - horizontalScrollBar.Height);
3973 } else if (horizontalScrollBar.Visible)
3974 horizontalScrollBar.Bounds = new Rectangle (BorderWidth, Height - BorderWidth - horizontalScrollBar.Height, Width - (2 * BorderWidth), horizontalScrollBar.Height);
3975 else if (verticalScrollBar.Visible)
3976 verticalScrollBar.Bounds = new Rectangle (Width - BorderWidth - verticalScrollBar.Width, BorderWidth, verticalScrollBar.Width, Height - (2 * BorderWidth));
3978 AutoResizeColumnsInternal ();
3982 protected override void OnLeave (EventArgs e)
3987 protected override void OnLostFocus(EventArgs e)
3989 base.OnLostFocus (e);
3991 // To remove focus rectangle if needed
3992 if (currentCell != null && ShowFocusCues)
3993 InvalidateCell (currentCell);
3996 protected override void OnMouseClick (MouseEventArgs e)
3998 base.OnMouseClick(e);
4000 if (column_resize_active || row_resize_active)
4003 //Console.WriteLine("Mouse: Clicks: {0}; Delta: {1}; X: {2}; Y: {3};", e.Clicks, e.Delta, e.X, e.Y);
4004 HitTestInfo hit = HitTest (e.X, e.Y);
4007 case DataGridViewHitTestType.Cell:
4008 Rectangle display = GetCellDisplayRectangle (hit.ColumnIndex, hit.RowIndex, false);
4009 Point cellpoint = new Point (e.X - display.X, e.Y - display.Y);
4011 OnCellMouseClick (new DataGridViewCellMouseEventArgs (hit.ColumnIndex, hit.RowIndex, cellpoint.X, cellpoint.Y, e));
4013 DataGridViewCell cell = GetCellInternal (hit.ColumnIndex, hit.RowIndex);
4015 if (cell.GetContentBounds (hit.RowIndex).Contains (cellpoint)) {
4016 DataGridViewCellEventArgs dgvcea = new DataGridViewCellEventArgs (hit.ColumnIndex, hit.RowIndex);
4017 OnCellContentClick (dgvcea);
4021 case DataGridViewHitTestType.ColumnHeader:
4022 Rectangle display2 = GetCellDisplayRectangle (hit.ColumnIndex, hit.RowIndex, false);
4023 Point cellpoint2 = new Point (e.X - display2.X, e.Y - display2.Y);
4025 OnColumnHeaderMouseClick (new DataGridViewCellMouseEventArgs (hit.ColumnIndex, hit.RowIndex, cellpoint2.X, cellpoint2.Y, e));
4030 protected override void OnMouseDoubleClick (MouseEventArgs e)
4032 base.OnMouseDoubleClick(e);
4035 private void DoSelectionOnMouseDown (HitTestInfo hitTest)
4037 Keys modifiers = Control.ModifierKeys;
4038 bool isControl = (modifiers & Keys.Control) != 0;
4039 bool isShift = (modifiers & Keys.Shift) != 0;
4040 //bool isRowHeader = hitTest.Type == DataGridViewHitTestType.RowHeader;
4041 //bool isColHeader = hitTest.Type == DataGridViewHitTestType.ColumnHeader;
4042 DataGridViewSelectionMode mode;
4044 switch (hitTest.Type) {
4045 case DataGridViewHitTestType.Cell:
4046 mode = selectionMode;
4048 case DataGridViewHitTestType.ColumnHeader:
4049 mode = selectionMode == DataGridViewSelectionMode.ColumnHeaderSelect ? DataGridViewSelectionMode.FullColumnSelect : selectionMode;
4051 if (mode != DataGridViewSelectionMode.FullColumnSelect)
4054 case DataGridViewHitTestType.RowHeader:
4055 mode = selectionMode == DataGridViewSelectionMode.RowHeaderSelect ? DataGridViewSelectionMode.FullRowSelect : selectionMode;
4057 if (mode != DataGridViewSelectionMode.FullRowSelect)
4059 break; // Handled below
4065 // If SHIFT is pressed:
4066 // Select all from selected_row/column/cell to current row/column/cell, unselect everything else
4068 // Unselect all rows/columns/cells, select the clicked one
4069 int min_row, max_row;
4070 int min_col, max_col;
4072 selected_row = hitTest.RowIndex;
4073 selected_column = hitTest.ColumnIndex;
4076 if (selected_row != -1)
4077 selected_row = hitTest.RowIndex;
4078 if (selected_column != -1)
4079 selected_column = hitTest.ColumnIndex;
4081 if (selected_row >= hitTest.RowIndex) {
4082 min_row = hitTest.RowIndex;
4083 max_row = isShift ? selected_row : min_row;
4085 max_row = hitTest.RowIndex;
4086 min_row = isShift ? selected_row : max_row;
4088 if (selected_column >= hitTest.ColumnIndex) {
4089 min_col = hitTest.ColumnIndex;
4090 max_col = isShift ? selected_column : min_col;
4092 max_col = hitTest.ColumnIndex;
4093 min_col = isShift ? selected_column : max_col;
4097 case DataGridViewSelectionMode.FullRowSelect:
4098 for (int i = 0; i < RowCount; i++) {
4099 bool select = i >= min_row && i <= max_row;
4101 for (int c = 0; c < ColumnCount; c++) {
4102 if (Rows [i].Cells [c].Selected) {
4103 SetSelectedCellCore (c, i, false);
4107 if (select != Rows [i].Selected) {
4108 SetSelectedRowCore (i, select);
4112 case DataGridViewSelectionMode.FullColumnSelect:
4113 for (int i = 0; i < ColumnCount; i++) {
4114 bool select = i >= min_col && i <= max_col;
4116 for (int r = 0; r < RowCount; r++) {
4117 if (Rows [r].Cells [i].Selected) {
4118 SetSelectedCellCore (i, r, false);
4122 if (select != Columns [i].Selected) {
4123 SetSelectedColumnCore (i, select);
4127 case DataGridViewSelectionMode.ColumnHeaderSelect:
4128 case DataGridViewSelectionMode.RowHeaderSelect:
4130 case DataGridViewSelectionMode.CellSelect:
4132 for (int c = 0; c < ColumnCount; c++) {
4133 if (columns [c].Selected)
4134 SetSelectedColumnCore (c, false);
4137 for (int r = 0; r < RowCount; r++) {
4138 if (rows [r].Selected)
4139 SetSelectedRowCore (r, false);
4142 for (int r = 0; r < RowCount; r++) {
4143 for (int c = 0; c < ColumnCount; c++) {
4144 bool select = (r >= min_row && r <= max_row) && (c >= min_col && c <= max_col);
4145 if (select != Rows [r].Cells [c].Selected)
4146 SetSelectedCellCore (c, r, select);
4152 } else if (isControl) {
4153 // Switch the selected state of the row.
4155 case DataGridViewSelectionMode.FullRowSelect:
4156 SetSelectedRowCore (hitTest.RowIndex, !rows [hitTest.RowIndex].Selected);
4158 case DataGridViewSelectionMode.FullColumnSelect:
4159 SetSelectedColumnCore (hitTest.ColumnIndex, !columns [hitTest.ColumnIndex].Selected);
4161 case DataGridViewSelectionMode.ColumnHeaderSelect:
4162 case DataGridViewSelectionMode.RowHeaderSelect:
4164 case DataGridViewSelectionMode.CellSelect:
4165 if (hitTest.ColumnIndex >= 0 && hitTest.RowIndex >= 0) {
4166 SetSelectedCellCore (hitTest.ColumnIndex, hitTest.RowIndex, !Rows [hitTest.RowIndex].Cells [hitTest.ColumnIndex].Selected);
4174 protected override void OnMouseDown (MouseEventArgs e)
4176 base.OnMouseDown(e);
4178 HitTestInfo hitTest = HitTest(e.X, e.Y);
4180 DataGridViewCell cell = null;
4181 DataGridViewRow row = null;
4182 Rectangle cellBounds;
4184 if (hitTest.Type == DataGridViewHitTestType.ColumnHeader && MouseOverColumnResize (hitTest.ColumnIndex, e.X)) {
4185 if (e.Clicks == 2) {
4187 AutoResizeColumn (hitTest.ColumnIndex);
4191 resize_band = hitTest.ColumnIndex;
4192 column_resize_active = true;
4193 resize_band_start = e.X;
4194 resize_band_delta = 0;
4196 DrawVerticalResizeLine (resize_band_start);
4200 if (hitTest.Type == DataGridViewHitTestType.RowHeader && MouseOverRowResize (hitTest.RowIndex, e.Y)) {
4201 if (e.Clicks == 2) {
4203 AutoResizeRow (hitTest.RowIndex);
4207 resize_band = hitTest.RowIndex;
4208 row_resize_active = true;
4209 resize_band_start = e.Y;
4210 resize_band_delta = 0;
4212 DrawHorizontalResizeLine (resize_band_start);
4216 if (hitTest.Type == DataGridViewHitTestType.Cell) {
4217 row = rows [hitTest.RowIndex];
4218 cell = row.Cells [hitTest.ColumnIndex];
4219 SetCurrentCellAddressCore (cell.ColumnIndex, cell.RowIndex, false, true, true);
4220 cellBounds = GetCellDisplayRectangle (hitTest.ColumnIndex, hitTest.RowIndex, false);
4221 OnCellMouseDown (new DataGridViewCellMouseEventArgs (hitTest.ColumnIndex, hitTest.RowIndex, e.X - cellBounds.X, e.Y - cellBounds.Y, e));
4222 OnCellClick (new DataGridViewCellEventArgs (hitTest.ColumnIndex, hitTest.RowIndex));
4225 DoSelectionOnMouseDown (hitTest);
4227 if (hitTest.Type != DataGridViewHitTestType.Cell) {
4228 if (hitTest.Type == DataGridViewHitTestType.ColumnHeader)
4229 pressed_header_cell = columns [hitTest.ColumnIndex].HeaderCell;
4230 else if (hitTest.Type == DataGridViewHitTestType.RowHeader)
4231 pressed_header_cell = rows [hitTest.RowIndex].HeaderCell;
4240 private void UpdateBindingPosition (int position)
4242 if (DataSource != null && BindingContext != null) {
4243 CurrencyManager currencyManager = this.BindingContext[DataSource] as CurrencyManager;
4244 if (currencyManager != null)
4245 currencyManager.Position = position;
4249 protected override void OnMouseEnter (EventArgs e)
4251 base.OnMouseEnter(e);
4254 protected override void OnMouseLeave (EventArgs e)
4256 base.OnMouseLeave (e);
4258 if (hover_cell != null) {
4259 OnCellMouseLeave (new DataGridViewCellEventArgs (hover_cell.ColumnIndex, hover_cell.RowIndex));
4263 EnteredHeaderCell = null;
4266 protected override void OnMouseMove (MouseEventArgs e)
4268 base.OnMouseMove (e);
4270 if (column_resize_active) {
4271 // Erase the old line
4272 DrawVerticalResizeLine (resize_band_start + resize_band_delta);
4274 resize_band_delta = e.X - resize_band_start;
4276 // Draw the new line
4277 DrawVerticalResizeLine (resize_band_start + resize_band_delta);
4281 if (row_resize_active) {
4282 // Erase the old line
4283 DrawHorizontalResizeLine (resize_band_start + resize_band_delta);
4285 resize_band_delta = e.Y - resize_band_start;
4287 // Draw the new line
4288 DrawHorizontalResizeLine (resize_band_start + resize_band_delta);
4292 Cursor new_cursor = Cursors.Default;
4293 HitTestInfo hit = this.HitTest (e.X, e.Y);
4295 if (hit.Type == DataGridViewHitTestType.Cell) {
4296 EnteredHeaderCell = null;
4298 DataGridViewCell new_cell = GetCellInternal (hit.ColumnIndex, hit.RowIndex);
4300 // Check if we have moved into an error icon area
4301 Rectangle icon = new_cell.ErrorIconBounds;
4303 if (!icon.IsEmpty) {
4304 Point loc = GetCellDisplayRectangle (hit.ColumnIndex, hit.RowIndex, false).Location;
4309 if (icon.Contains (e.X, e.Y)) {
4310 if (tooltip_currently_showing != new_cell)
4311 MouseEnteredErrorIcon (new_cell);
4313 MouseLeftErrorIcon (new_cell);
4316 // We have never been in a cell before
4317 if (hover_cell == null) {
4318 hover_cell = new_cell;
4319 OnCellMouseEnter (new DataGridViewCellEventArgs (hit.ColumnIndex, hit.RowIndex));
4321 Rectangle display = GetCellDisplayRectangle (hit.ColumnIndex, hit.RowIndex, false);
4322 OnCellMouseMove (new DataGridViewCellMouseEventArgs (hit.ColumnIndex, hit.RowIndex, e.X - display.X, e.Y - display.Y, e));
4327 // Were we already in this cell?
4328 if (hover_cell.RowIndex == hit.RowIndex && hover_cell.ColumnIndex == hit.ColumnIndex) {
4329 Rectangle display = GetCellDisplayRectangle (hit.ColumnIndex, hit.RowIndex, false);
4330 OnCellMouseMove (new DataGridViewCellMouseEventArgs (hit.ColumnIndex, hit.RowIndex, e.X - display.X, e.Y - display.Y, e));
4335 // We are changing cells
4336 OnCellMouseLeave (new DataGridViewCellEventArgs (hover_cell.ColumnIndex, hover_cell.RowIndex));
4338 hover_cell = new_cell;
4340 OnCellMouseEnter (new DataGridViewCellEventArgs (hit.ColumnIndex, hit.RowIndex));
4342 Rectangle display2 = GetCellDisplayRectangle (hit.ColumnIndex, hit.RowIndex, false);
4343 OnCellMouseMove (new DataGridViewCellMouseEventArgs (hit.ColumnIndex, hit.RowIndex, e.X - display2.X, e.Y - display2.Y, e));
4346 } else if (hit.Type == DataGridViewHitTestType.RowHeader) {
4347 DataGridViewRowHeaderCell new_cell = Rows[hit.RowIndex].HeaderCell;
4349 EnteredHeaderCell = new_cell;
4351 if (MouseOverRowResize (hit.RowIndex, e.Y))
4352 new_cursor = Cursors.HSplit;
4354 // Check if we have moved into an error icon area
4355 Rectangle icon = new_cell.InternalErrorIconsBounds;
4357 if (!icon.IsEmpty) {
4358 Point loc = GetCellDisplayRectangle (0, hit.RowIndex, false).Location;
4360 icon.X += BorderWidth;
4363 if (icon.Contains (e.X, e.Y)) {
4364 if (tooltip_currently_showing != new_cell)
4365 MouseEnteredErrorIcon (new_cell);
4367 MouseLeftErrorIcon (new_cell);
4369 } else if (hit.Type == DataGridViewHitTestType.TopLeftHeader) {
4370 EnteredHeaderCell = null;
4372 DataGridViewTopLeftHeaderCell new_cell = (DataGridViewTopLeftHeaderCell)TopLeftHeaderCell;
4374 // Check if we have moved into an error icon area
4375 Rectangle icon = new_cell.InternalErrorIconsBounds;
4377 if (!icon.IsEmpty) {
4378 Point loc = Point.Empty;
4380 icon.X += BorderWidth;
4383 if (icon.Contains (e.X, e.Y)) {
4384 if (tooltip_currently_showing != new_cell)
4385 MouseEnteredErrorIcon (new_cell);
4387 MouseLeftErrorIcon (new_cell);
4391 if (hit.Type == DataGridViewHitTestType.ColumnHeader) {
4392 EnteredHeaderCell = Columns [hit.ColumnIndex].HeaderCell;
4394 if (MouseOverColumnResize (hit.ColumnIndex, e.X))
4395 new_cursor = Cursors.VSplit;
4397 EnteredHeaderCell = null;
4399 // We have left the cell area
4400 if (hover_cell != null) {
4401 OnCellMouseLeave (new DataGridViewCellEventArgs (hover_cell.ColumnIndex, hover_cell.RowIndex));
4406 Cursor = new_cursor;
4409 protected override void OnMouseUp (MouseEventArgs e)
4413 if (column_resize_active) {
4414 column_resize_active = false;
4416 if (resize_band_delta + Columns[resize_band].Width < 0)
4417 resize_band_delta = -Columns[resize_band].Width;
4419 Columns[resize_band].Width = Math.Max (resize_band_delta + Columns[resize_band].Width, Columns[resize_band].MinimumWidth);
4424 if (row_resize_active) {
4425 row_resize_active = false;
4427 if (resize_band_delta + Rows[resize_band].Height < 0)
4428 resize_band_delta = -Rows[resize_band].Height;
4430 Rows[resize_band].Height = Math.Max (resize_band_delta + Rows[resize_band].Height, Rows[resize_band].MinimumHeight);
4435 HitTestInfo hit = this.HitTest (e.X, e.Y);
4437 if (hit.Type == DataGridViewHitTestType.Cell) {
4438 Rectangle display = GetCellDisplayRectangle (hit.ColumnIndex, hit.RowIndex, false);
4439 OnCellMouseUp (new DataGridViewCellMouseEventArgs (hit.ColumnIndex, hit.RowIndex, e.X - display.X, e.Y - display.Y, e));
4442 if (pressed_header_cell != null) {
4443 DataGridViewHeaderCell cell = pressed_header_cell;
4444 pressed_header_cell = null;
4445 if (ThemeEngine.Current.DataGridViewHeaderCellHasPressedStyle (this))
4446 Invalidate (GetHeaderCellBounds (cell));
4450 protected override void OnMouseWheel (MouseEventArgs e)
4452 base.OnMouseWheel(e);
4455 protected virtual void OnMultiSelectChanged (EventArgs e)
4457 EventHandler eh = (EventHandler)(Events [MultiSelectChangedEvent]);
4458 if (eh != null) eh (this, e);
4461 protected virtual void OnNewRowNeeded (DataGridViewRowEventArgs e) {
4462 DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [NewRowNeededEvent]);
4463 if (eh != null) eh (this, e);
4466 int first_row_index = 0;
4467 internal int first_col_index = 0;
4469 protected override void OnPaint (PaintEventArgs e)
4473 Graphics g = e.Graphics;
4474 Rectangle bounds = ClientRectangle;
4476 // Paint the background
4477 PaintBackground (g, e.ClipRectangle, bounds);
4479 List<DataGridViewColumn> sortedColumns = columns.ColumnDisplayIndexSortedArrayList;
4481 // Take borders into account
4482 bounds.Inflate (-BorderWidth, -BorderWidth);
4484 // Paint the top left cell
4485 if (rowHeadersVisible && columnHeadersVisible && ColumnCount > 0) {
4486 Rectangle topleftbounds = new Rectangle (bounds.X, bounds.Y, rowHeadersWidth, columnHeadersHeight);
4488 TopLeftHeaderCell.PaintWork (g, e.ClipRectangle, topleftbounds, -1, TopLeftHeaderCell.State, ColumnHeadersDefaultCellStyle, AdvancedColumnHeadersBorderStyle, DataGridViewPaintParts.All);
4491 // Paint the column headers
4492 if (columnHeadersVisible) {
4493 Rectangle headerBounds = bounds;
4494 headerBounds.Height = columnHeadersHeight;
4496 if (rowHeadersVisible)
4497 headerBounds.X += rowHeadersWidth;
4499 for (int index = first_col_index; index < sortedColumns.Count; index++) {
4500 DataGridViewColumn col = sortedColumns[index];
4505 headerBounds.Width = col.Width;
4506 DataGridViewCell cell = col.HeaderCell;
4508 DataGridViewAdvancedBorderStyle intermediateBorderStyle = (DataGridViewAdvancedBorderStyle)((ICloneable)this.AdvancedColumnHeadersBorderStyle).Clone ();
4509 DataGridViewAdvancedBorderStyle borderStyle = AdjustColumnHeaderBorderStyle (this.AdvancedColumnHeadersBorderStyle, intermediateBorderStyle, cell.ColumnIndex == 0, cell.ColumnIndex == columns.Count - 1);
4511 cell.PaintWork (g, e.ClipRectangle, headerBounds, -1, cell.State, cell.InheritedStyle, borderStyle, DataGridViewPaintParts.All);
4513 headerBounds.X += col.Width;
4516 bounds.Y += columnHeadersHeight;
4519 gridWidth = rowHeadersVisible ? rowHeadersWidth : 0;
4522 int first_row_height = Rows.Count > 0 ? Rows[Math.Min (Rows.Count - 1, first_row_index)].Height : 0;
4523 // int room_left = this.Height;
4525 // Reset all columns to !Displayed
4526 for (int i = 0; i < Columns.Count; i++)
4527 Columns[i].DisplayedInternal = false;
4529 // Set Displayed columns
4530 for (int i = first_col_index; i < Columns.Count; i++) {
4531 DataGridViewColumn col = Columns.ColumnDisplayIndexSortedArrayList[i];
4536 col.DisplayedInternal = true;
4537 gridWidth += col.Width;
4539 if (gridWidth >= Width)
4543 // Reset all rows to !Displayed
4544 for (int i = 0; i < Rows.Count; i++)
4545 GetRowInternal (i).DisplayedInternal = false;
4548 for (int index = first_row_index; index < Rows.Count; index++) {
4549 DataGridViewRow row = Rows[index];
4550 GetRowInternal (index).DisplayedInternal = true;
4552 bounds.Height = row.Height;
4553 bool is_first = row.Index == 0;
4554 bool is_last = row.Index == rows.Count - 1;
4556 row.Paint (g, e.ClipRectangle, bounds, row.Index, row.GetState (row.Index), is_first, is_last);
4558 bounds.Y += bounds.Height;
4559 bounds.X = BorderWidth;
4561 if (bounds.Y >= ClientSize.Height - (horizontalScrollBar.Visible ? horizontalScrollBar.Height : 0))
4564 gridHeight += row.Height;
4569 foreach (DataGridViewColumn col in sortedColumns)
4571 gridWidth += col.Width;
4575 foreach (DataGridViewRow row in Rows)
4576 gridHeight += row.Height;
4578 if (rowHeadersVisible)
4579 gridWidth += rowHeadersWidth;
4581 if (columnHeadersVisible)
4582 gridHeight += columnHeadersHeight;
4584 bool horizontalVisible = false;
4585 bool verticalVisible = false;
4588 if (gridWidth > Size.Width || gridHeight > Size.Height) {
4589 Size = new Size(gridWidth, gridHeight);
4593 if (gridWidth > Size.Width) {
4594 horizontalVisible = true;
4596 if (gridHeight > Size.Height) {
4597 verticalVisible = true;
4599 if (horizontalScrollBar.Visible && (gridHeight + horizontalScrollBar.Height) > Size.Height) {
4600 verticalVisible = true;
4602 if (verticalScrollBar.Visible && (gridWidth + verticalScrollBar.Width) > Size.Width) {
4603 horizontalVisible = true;
4605 if (horizontalVisible) {
4606 horizontalScrollBar.Minimum = 0;
4607 horizontalScrollBar.Maximum = gridWidth;
4608 horizontalScrollBar.SmallChange = Columns[first_col_index].Width;
4609 horizontalScrollBar.LargeChange = ClientSize.Width - rowHeadersWidth;
4611 if (verticalVisible) {
4612 verticalScrollBar.Minimum = 0;
4613 verticalScrollBar.Maximum = gridHeight;
4614 verticalScrollBar.SmallChange = first_row_height + 1;
4615 verticalScrollBar.LargeChange = ClientSize.Height - columnHeadersHeight;
4619 horizontalScrollBar.Visible = horizontalVisible;
4620 verticalScrollBar.Visible = verticalVisible;
4622 // Paint the bottom right square if both scrollbars are displayed
4623 if (horizontalScrollBar.Visible && verticalScrollBar.Visible)
4624 g.FillRectangle (SystemBrushes.Control, new Rectangle (horizontalScrollBar.Right, verticalScrollBar.Bottom, verticalScrollBar.Width, horizontalScrollBar.Height));
4627 bounds = ClientRectangle;
4629 switch (BorderStyle) {
4630 case BorderStyle.FixedSingle:
4631 g.DrawRectangle (Pens.Black, new Rectangle (bounds.Left, bounds.Top, bounds.Width - 1, bounds.Height - 1));
4633 case BorderStyle.Fixed3D:
4634 ControlPaint.DrawBorder3D (g, bounds, Border3DStyle.Sunken);
4639 protected virtual void OnReadOnlyChanged (EventArgs e) {
4640 EventHandler eh = (EventHandler)(Events [ReadOnlyChangedEvent]);
4645 protected override void OnResize (EventArgs e) {
4647 AutoResizeColumnsInternal ();
4649 OnVScrollBarScroll (this, new ScrollEventArgs (ScrollEventType.ThumbPosition, verticalScrollBar.Value));
4650 OnHScrollBarScroll (this, new ScrollEventArgs (ScrollEventType.ThumbPosition, horizontalScrollBar.Value));
4653 protected override void OnRightToLeftChanged (EventArgs e) {
4654 base.OnRightToLeftChanged(e);
4657 // In MSDN2 documentation there's no internal here
4658 protected internal virtual void OnRowContextMenuStripChanged (DataGridViewRowEventArgs e)
4660 DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowContextMenuStripChangedEvent]);
4661 if (eh != null) eh (this, e);
4664 protected virtual void OnRowContextMenuStripNeeded (DataGridViewRowContextMenuStripNeededEventArgs e)
4666 DataGridViewRowContextMenuStripNeededEventHandler eh = (DataGridViewRowContextMenuStripNeededEventHandler)(Events [RowContextMenuStripNeededEvent]);
4667 if (eh != null) eh (this, e);
4670 protected internal virtual void OnRowDefaultCellStyleChanged (DataGridViewRowEventArgs e)
4672 DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowDefaultCellStyleChangedEvent]);
4673 if (eh != null) eh (this, e);
4676 protected virtual void OnRowDirtyStateNeeded (QuestionEventArgs e)
4678 QuestionEventHandler eh = (QuestionEventHandler)(Events [RowDirtyStateNeededEvent]);
4679 if (eh != null) eh (this, e);
4682 protected virtual void OnRowDividerDoubleClick (DataGridViewRowDividerDoubleClickEventArgs e)
4684 DataGridViewRowDividerDoubleClickEventHandler eh = (DataGridViewRowDividerDoubleClickEventHandler)(Events [RowDividerDoubleClickEvent]);
4685 if (eh != null) eh (this, e);
4688 protected virtual void OnRowDividerHeightChanged (DataGridViewRowEventArgs e)
4690 DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowDividerHeightChangedEvent]);
4691 if (eh != null) eh (this, e);
4694 protected virtual void OnRowEnter (DataGridViewCellEventArgs e)
4696 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [RowEnterEvent]);
4697 if (eh != null) eh (this, e);
4700 protected internal virtual void OnRowErrorTextChanged (DataGridViewRowEventArgs e)
4702 DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowErrorTextChangedEvent]);
4703 if (eh != null) eh (this, e);
4706 protected virtual void OnRowErrorTextNeeded (DataGridViewRowErrorTextNeededEventArgs e)
4708 DataGridViewRowErrorTextNeededEventHandler eh = (DataGridViewRowErrorTextNeededEventHandler)(Events [RowErrorTextNeededEvent]);
4709 if (eh != null) eh (this, e);
4712 protected internal virtual void OnRowHeaderCellChanged (DataGridViewRowEventArgs e)
4714 DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowHeaderCellChangedEvent]);
4715 if (eh != null) eh (this, e);
4718 protected virtual void OnRowHeaderMouseClick (DataGridViewCellMouseEventArgs e)
4720 DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [RowHeaderMouseClickEvent]);
4721 if (eh != null) eh (this, e);
4724 protected virtual void OnRowHeaderMouseDoubleClick (DataGridViewCellMouseEventArgs e)
4726 DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [RowHeaderMouseDoubleClickEvent]);
4727 if (eh != null) eh (this, e);
4730 protected virtual void OnRowHeadersBorderStyleChanged (EventArgs e)
4732 EventHandler eh = (EventHandler)(Events [RowHeadersBorderStyleChangedEvent]);
4733 if (eh != null) eh (this, e);
4736 protected virtual void OnRowHeadersDefaultCellStyleChanged (EventArgs e)
4738 EventHandler eh = (EventHandler)(Events [RowHeadersDefaultCellStyleChangedEvent]);
4739 if (eh != null) eh (this, e);
4742 protected virtual void OnRowHeadersWidthChanged (EventArgs e)
4744 EventHandler eh = (EventHandler)(Events [RowHeadersWidthChangedEvent]);
4745 if (eh != null) eh (this, e);
4748 protected virtual void OnRowHeadersWidthSizeModeChanged (DataGridViewAutoSizeModeEventArgs e)
4750 DataGridViewAutoSizeModeEventHandler eh = (DataGridViewAutoSizeModeEventHandler)(Events [RowHeadersWidthSizeModeChangedEvent]);
4751 if (eh != null) eh (this, e);
4754 protected internal virtual void OnRowHeightChanged (DataGridViewRowEventArgs e)
4756 DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowHeightChangedEvent]);
4757 if (eh != null) eh (this, e);
4760 protected virtual void OnRowHeightInfoNeeded (DataGridViewRowHeightInfoNeededEventArgs e)
4762 DataGridViewRowHeightInfoNeededEventHandler eh = (DataGridViewRowHeightInfoNeededEventHandler)(Events [RowHeightInfoNeededEvent]);
4763 if (eh != null) eh (this, e);
4766 protected virtual void OnRowHeightInfoPushed (DataGridViewRowHeightInfoPushedEventArgs e)
4768 DataGridViewRowHeightInfoPushedEventHandler eh = (DataGridViewRowHeightInfoPushedEventHandler)(Events [RowHeightInfoPushedEvent]);
4769 if (eh != null) eh (this, e);
4772 protected virtual void OnRowLeave (DataGridViewCellEventArgs e)
4774 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [RowLeaveEvent]);
4775 if (eh != null) eh (this, e);
4778 protected internal virtual void OnRowMinimumHeightChanged (DataGridViewRowEventArgs e)
4780 DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowMinimumHeightChangedEvent]);
4781 if (eh != null) eh (this, e);
4784 protected internal virtual void OnRowPostPaint (DataGridViewRowPostPaintEventArgs e)
4786 DataGridViewRowPostPaintEventHandler eh = (DataGridViewRowPostPaintEventHandler)(Events [RowPostPaintEvent]);
4787 if (eh != null) eh (this, e);
4790 protected internal virtual void OnRowPrePaint (DataGridViewRowPrePaintEventArgs e)
4792 DataGridViewRowPrePaintEventHandler eh = (DataGridViewRowPrePaintEventHandler)(Events [RowPrePaintEvent]);
4793 if (eh != null) eh (this, e);
4796 internal void OnRowsAddedInternal (DataGridViewRowsAddedEventArgs e)
4802 protected internal virtual void OnRowsAdded (DataGridViewRowsAddedEventArgs e)
4804 DataGridViewRowsAddedEventHandler eh = (DataGridViewRowsAddedEventHandler)(Events [RowsAddedEvent]);
4805 if (eh != null) eh (this, e);
4808 protected virtual void OnRowsDefaultCellStyleChanged (EventArgs e)
4810 EventHandler eh = (EventHandler)(Events [RowsDefaultCellStyleChangedEvent]);
4811 if (eh != null) eh (this, e);
4814 internal void OnRowsRemovedInternal (DataGridViewRowsRemovedEventArgs e)
4816 if (selected_rows != null)
4817 selected_rows.InternalClear ();
4818 if (selected_columns != null)
4819 selected_columns.InternalClear ();
4821 if (Rows.Count > 0 && Columns.Count > 0 && currentCell != null &&
4822 currentCell.RowIndex >= e.RowIndex)
4823 MoveCurrentCell (0, Math.Min (e.RowIndex, Rows.Count - 2), true, false, false, true);
4828 protected virtual void OnRowsRemoved (DataGridViewRowsRemovedEventArgs e)
4830 DataGridViewRowsRemovedEventHandler eh = (DataGridViewRowsRemovedEventHandler)(Events [RowsRemovedEvent]);
4831 if (eh != null) eh (this, e);
4834 protected internal virtual void OnRowStateChanged (int rowIndex, DataGridViewRowStateChangedEventArgs e)
4836 DataGridViewRowStateChangedEventHandler eh = (DataGridViewRowStateChangedEventHandler)(Events [RowStateChangedEvent]);
4837 if (eh != null) eh (this, e);
4840 protected virtual void OnRowUnshared (DataGridViewRowEventArgs e)
4842 DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowUnsharedEvent]);
4843 if (eh != null) eh (this, e);
4846 protected virtual void OnRowValidated (DataGridViewCellEventArgs e)
4848 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [RowValidatedEvent]);
4849 if (eh != null) eh (this, e);
4852 protected virtual void OnRowValidating (DataGridViewCellCancelEventArgs e)
4854 DataGridViewCellCancelEventHandler eh = (DataGridViewCellCancelEventHandler)(Events [RowValidatingEvent]);
4855 if (eh != null) eh (this, e);
4858 protected virtual void OnScroll (ScrollEventArgs e)
4860 ScrollEventHandler eh = (ScrollEventHandler)(Events [ScrollEvent]);
4861 if (eh != null) eh (this, e);
4864 protected virtual void OnSelectionChanged (EventArgs e)
4866 EventHandler eh = (EventHandler)(Events [SelectionChangedEvent]);
4867 if (eh != null) eh (this, e);
4870 protected virtual void OnSortCompare (DataGridViewSortCompareEventArgs e) {
4871 DataGridViewSortCompareEventHandler eh = (DataGridViewSortCompareEventHandler)(Events [SortCompareEvent]);
4872 if (eh != null) eh (this, e);
4875 protected virtual void OnSorted (EventArgs e)
4877 EventHandler eh = (EventHandler)(Events [SortedEvent]);
4878 if (eh != null) eh (this, e);
4881 protected virtual void OnUserAddedRow (DataGridViewRowEventArgs e)
4884 PrepareEditingRow (false, false);
4886 e = new DataGridViewRowEventArgs (editing_row);
4888 DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [UserAddedRowEvent]);
4889 if (eh != null) eh (this, e);
4892 protected virtual void OnUserDeletedRow (DataGridViewRowEventArgs e)
4894 DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [UserDeletedRowEvent]);
4895 if (eh != null) eh (this, e);
4899 protected virtual void OnUserDeletingRow (DataGridViewRowCancelEventArgs e)
4901 DataGridViewRowCancelEventHandler eh = (DataGridViewRowCancelEventHandler)(Events [UserDeletingRowEvent]);
4902 if (eh != null) eh (this, e);
4905 protected override void OnValidating (CancelEventArgs e)
4907 base.OnValidating(e);
4910 protected override void OnVisibleChanged (EventArgs e)
4912 base.OnVisibleChanged(e);
4915 protected virtual void PaintBackground (Graphics graphics, Rectangle clipBounds, Rectangle gridBounds)
4917 graphics.FillRectangle (ThemeEngine.Current.ResPool.GetSolidBrush (backgroundColor), gridBounds);
4920 protected bool ProcessAKey (Keys keyData)
4925 if ((keyData & Keys.Control) == Keys.Control) {
4933 protected virtual bool ProcessDataGridViewKey (KeyEventArgs e)
4935 switch (e.KeyData & ~Keys.Modifiers) {
4937 return ProcessAKey (e.KeyData);
4939 return ProcessDeleteKey (e.KeyData);
4941 return ProcessDownKey (e.KeyData);
4943 return ProcessEscapeKey (e.KeyData);
4945 return ProcessEndKey (e.KeyData);
4947 return ProcessEnterKey (e.KeyData);
4949 return ProcessF2Key (e.KeyData);
4951 return ProcessHomeKey (e.KeyData);
4953 return ProcessLeftKey (e.KeyData);
4955 return ProcessNextKey (e.KeyData);
4957 return ProcessPriorKey (e.KeyData);
4959 return ProcessRightKey (e.KeyData);
4961 return ProcessSpaceKey (e.KeyData);
4963 return ProcessTabKey (e.KeyData);
4965 return ProcessUpKey (e.KeyData);
4968 return ProcessZeroKey (e.KeyData);
4974 protected bool ProcessDeleteKey (Keys keyData)
4976 if (!allowUserToDeleteRows || SelectedRows.Count == 0)
4979 int index = Math.Max (selected_row - SelectedRows.Count + 1, 0);
4981 for (int i = SelectedRows.Count - 1; i >= 0; i--) {
4982 DataGridViewRow row = SelectedRows[i];
4987 if (hover_cell != null && hover_cell.OwningRow == row)
4990 if (DataSource != null && DataSource is DataSet)
4991 (DataSource as DataSet).Tables[dataMember].Rows.RemoveAt (row.Index);
4993 Rows.RemoveAt (row.Index);
4999 protected override bool ProcessDialogKey (Keys keyData)
5003 case Keys.Shift | Keys.Tab:
5005 return base.ProcessDialogKey (keyData & ~Keys.Control);
5007 if (ProcessDataGridViewKey (new KeyEventArgs (keyData)))
5011 case Keys.Control | Keys.Tab:
5012 case Keys.Control | Keys.Shift | Keys.Tab:
5014 return base.ProcessDialogKey (keyData & ~Keys.Control);
5016 if (ProcessDataGridViewKey (new KeyEventArgs (keyData)))
5022 if (ProcessDataGridViewKey (new KeyEventArgs (keyData)))
5028 return base.ProcessDialogKey(keyData);
5031 protected bool ProcessDownKey (Keys keyData)
5033 int current_row = CurrentCellAddress.Y;
5035 if (current_row < Rows.Count - 1) {
5036 // Move to the last cell in the column
5037 if ((keyData & Keys.Control) == Keys.Control)
5038 MoveCurrentCell (CurrentCellAddress.X, Rows.Count - 1, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5039 // Move one cell down
5041 MoveCurrentCell (CurrentCellAddress.X, current_row + 1, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5049 protected bool ProcessEndKey (Keys keyData)
5051 int disp_index = ColumnIndexToDisplayIndex (currentCellAddress.X);
5053 // Move to the last cell in the control
5054 if ((keyData & Keys.Control) == Keys.Control) {
5055 MoveCurrentCell (ColumnDisplayIndexToIndex (Columns.Count - 1), Rows.Count - 1, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5059 // Move to the last cell in the row
5060 if (disp_index < Columns.Count - 1) {
5061 MoveCurrentCell (ColumnDisplayIndexToIndex (Columns.Count - 1), currentCellAddress.Y, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5068 protected bool ProcessEnterKey (Keys keyData)
5070 if (ProcessDownKey (keyData))
5073 // ProcessDown may fail if we are on the last row,
5074 // but Enter should still EndEdit if this is the last row
5079 protected bool ProcessEscapeKey (Keys keyData)
5081 if (!IsCurrentCellInEditMode)
5088 protected bool ProcessF2Key (Keys keyData)
5090 if (editMode == DataGridViewEditMode.EditOnF2 || editMode == DataGridViewEditMode.EditOnKeystrokeOrF2) {
5098 protected bool ProcessHomeKey (Keys keyData)
5100 int disp_index = ColumnIndexToDisplayIndex (currentCellAddress.X);
5102 // Move to the first cell in the control
5103 if ((keyData & Keys.Control) == Keys.Control) {
5104 MoveCurrentCell (ColumnDisplayIndexToIndex (0), 0, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5108 // Move to the first cell in the row
5109 if (disp_index > 0) {
5110 MoveCurrentCell (ColumnDisplayIndexToIndex (0), currentCellAddress.Y, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5117 [MonoTODO ("What does insert do?")]
5118 protected bool ProcessInsertKey (Keys keyData)
5123 protected override bool ProcessKeyEventArgs (ref Message m)
5125 DataGridViewCell cell = CurrentCell;
5128 if (cell.KeyEntersEditMode (new KeyEventArgs ((Keys)m.WParam.ToInt32 ())))
5131 return base.ProcessKeyEventArgs (ref m);
5134 protected override bool ProcessKeyPreview (ref Message m)
5136 if ((Msg)m.Msg == Msg.WM_KEYDOWN && (IsCurrentCellInEditMode || m.HWnd == horizontalScrollBar.Handle || m.HWnd == verticalScrollBar.Handle)) {
5137 KeyEventArgs e = new KeyEventArgs ((Keys)m.WParam.ToInt32 ());
5139 IDataGridViewEditingControl ctrl = (IDataGridViewEditingControl)EditingControlInternal;
5142 if (ctrl.EditingControlWantsInputKey (e.KeyData, false))
5145 switch (e.KeyData) {
5154 return ProcessDataGridViewKey (e);
5158 return base.ProcessKeyPreview (ref m);
5161 protected bool ProcessLeftKey (Keys keyData)
5163 int disp_index = ColumnIndexToDisplayIndex (currentCellAddress.X);
5165 if (disp_index > 0) {
5166 // Move to the first cell in the row
5167 if ((keyData & Keys.Control) == Keys.Control)
5168 MoveCurrentCell (ColumnDisplayIndexToIndex (0), currentCellAddress.Y, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5169 // Move one cell to the left
5171 MoveCurrentCell (ColumnDisplayIndexToIndex (disp_index - 1), currentCellAddress.Y, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5180 protected bool ProcessNextKey (Keys keyData)
5182 int current_row = CurrentCellAddress.Y;
5184 if (current_row < Rows.Count - 1) {
5185 // Move one "page" of cells down
5186 int new_row = Math.Min (Rows.Count - 1, current_row + DisplayedRowCount (false));
5188 MoveCurrentCell (CurrentCellAddress.X, new_row, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5197 protected bool ProcessPriorKey (Keys keyData)
5199 int current_row = CurrentCellAddress.Y;
5201 if (current_row > 0) {
5202 // Move one "page" of cells up
5203 int new_row = Math.Max (0, current_row - DisplayedRowCount (false));
5205 MoveCurrentCell (CurrentCellAddress.X, new_row, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5213 protected bool ProcessRightKey (Keys keyData)
5215 int disp_index = ColumnIndexToDisplayIndex (currentCellAddress.X);
5217 if (disp_index < Columns.Count - 1) {
5218 // Move to the last cell in the row
5219 if ((keyData & Keys.Control) == Keys.Control)
5220 MoveCurrentCell (ColumnDisplayIndexToIndex (Columns.Count - 1), currentCellAddress.Y, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5221 // Move one cell to the right
5223 MoveCurrentCell (ColumnDisplayIndexToIndex (disp_index + 1), currentCellAddress.Y, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5231 protected bool ProcessSpaceKey (Keys keyData)
5233 if ((keyData & Keys.Shift) == Keys.Shift) {
5234 if (selectionMode == DataGridViewSelectionMode.RowHeaderSelect) {
5235 SetSelectedRowCore (CurrentCellAddress.Y, true);
5236 InvalidateRow (CurrentCellAddress.Y);
5239 if (selectionMode == DataGridViewSelectionMode.ColumnHeaderSelect) {
5240 SetSelectedColumnCore (CurrentCellAddress.X, true);
5241 InvalidateColumn (CurrentCellAddress.X);
5246 if (CurrentCell is DataGridViewButtonCell || CurrentCell is DataGridViewLinkCell || CurrentCell is DataGridViewCheckBoxCell) {
5247 DataGridViewCellEventArgs e = new DataGridViewCellEventArgs (CurrentCell.ColumnIndex, CurrentCell.RowIndex);
5250 OnCellContentClick (e);
5252 if (CurrentCell is DataGridViewButtonCell)
5253 (CurrentCell as DataGridViewButtonCell).OnClickInternal (e);
5254 if (CurrentCell is DataGridViewCheckBoxCell)
5255 (CurrentCell as DataGridViewCheckBoxCell).OnClickInternal (e);
5263 protected bool ProcessTabKey (Keys keyData)
5265 Form f = FindForm ();
5268 f.ActivateFocusCues ();
5270 int disp_index = ColumnIndexToDisplayIndex (currentCellAddress.X);
5273 // Shift-tab goes backwards
5274 if ((keyData & Keys.Shift) == Keys.Shift) {
5275 if (disp_index > 0) {
5276 // Move one cell to the left
5277 MoveCurrentCell (ColumnDisplayIndexToIndex (disp_index - 1), currentCellAddress.Y, true, (keyData & Keys.Control) == Keys.Control, false, true);
5279 } else if (currentCellAddress.Y > 0) {
5280 // Move to the last cell in the previous row
5281 MoveCurrentCell (ColumnDisplayIndexToIndex (Columns.Count - 1), currentCellAddress.Y - 1, true, false, false, true);
5286 if (disp_index < Columns.Count - 1) {
5287 // Move one cell to the right
5288 MoveCurrentCell (ColumnDisplayIndexToIndex (disp_index + 1), currentCellAddress.Y, true, (keyData & Keys.Control) == Keys.Control, false, true);
5291 } else if (currentCellAddress.Y < Rows.Count - 1) {
5292 // Move to the first cell in the next row
5293 MoveCurrentCell (ColumnDisplayIndexToIndex (0), currentCellAddress.Y + 1, true, false, false, true);
5303 protected bool ProcessUpKey (Keys keyData)
5305 int current_row = CurrentCellAddress.Y;
5307 if (current_row > 0) {
5308 // Move to the first cell in the column
5309 if ((keyData & Keys.Control) == Keys.Control)
5310 MoveCurrentCell (CurrentCellAddress.X, 0, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5313 MoveCurrentCell (CurrentCellAddress.X, current_row - 1, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5321 protected bool ProcessZeroKey (Keys keyData)
5323 if ((keyData & Keys.Control) == Keys.Control && CurrentCell.EditType != null) {
5324 CurrentCell.Value = DBNull.Value;
5325 InvalidateCell (CurrentCell);
5332 protected override void SetBoundsCore (int x, int y, int width, int height, BoundsSpecified specified) {
5333 base.SetBoundsCore(x, y, width, height, specified);
5336 [MonoTODO ("Does not use validateCurrentCell")]
5337 protected virtual bool SetCurrentCellAddressCore (int columnIndex, int rowIndex, bool setAnchorCellAddress, bool validateCurrentCell, bool throughMouseClick)
5339 if ((columnIndex < 0 || columnIndex > Columns.Count - 1) && rowIndex != -1)
5340 throw new ArgumentOutOfRangeException ("columnIndex");
5341 if ((rowIndex < 0 || rowIndex > Rows.Count - 1) && columnIndex != -1)
5342 throw new ArgumentOutOfRangeException ("rowIndex");
5344 DataGridViewCell cell;
5346 if (columnIndex == -1 && rowIndex == -1)
5349 cell = Rows.SharedRow (rowIndex).Cells[columnIndex];
5351 if (cell != null && !cell.Visible)
5352 throw new InvalidOperationException ("cell is not visible");
5354 if (setAnchorCellAddress)
5355 anchor_cell = new Point (columnIndex, rowIndex);
5357 if (cell != currentCell) {
5358 if (currentCell != null) {
5359 if (currentCell.IsInEditMode)
5361 OnCellLeave (new DataGridViewCellEventArgs(currentCell.ColumnIndex, currentCell.RowIndex));
5362 OnRowLeave (new DataGridViewCellEventArgs (currentCell.ColumnIndex, currentCell.RowIndex));
5366 currentCellAddress = new Point (columnIndex, rowIndex);
5368 UpdateBindingPosition (currentCell.RowIndex);
5369 OnRowEnter (new DataGridViewCellEventArgs (cell.ColumnIndex, cell.RowIndex));
5370 OnCellEnter (new DataGridViewCellEventArgs(cell.ColumnIndex, cell.RowIndex));
5371 OnCurrentCellChanged (EventArgs.Empty);
5372 if (throughMouseClick || editMode == DataGridViewEditMode.EditOnEnter)
5375 if (throughMouseClick)
5382 protected virtual void SetSelectedCellCore (int columnIndex, int rowIndex, bool selected) {
5383 rows [rowIndex].Cells [columnIndex].Selected = selected;
5385 OnSelectionChanged (EventArgs.Empty);
5388 internal void SetSelectedColumnCoreInternal (int columnIndex, bool selected) {
5389 SetSelectedColumnCore (columnIndex, selected);
5392 protected virtual void SetSelectedColumnCore (int columnIndex, bool selected) {
5393 if (selectionMode != DataGridViewSelectionMode.ColumnHeaderSelect && selectionMode != DataGridViewSelectionMode.FullColumnSelect)
5396 DataGridViewColumn col = columns [columnIndex];
5398 col.SelectedInternal = selected;
5400 if (selected_columns == null)
5401 selected_columns = new DataGridViewSelectedColumnCollection ();
5403 if (!selected && selected_columns.Contains (col)) {
5404 selected_columns.InternalRemove (col);
5405 } else if (selected && !selected_columns.Contains (col)) {
5406 selected_columns.InternalAdd (col);
5412 internal void SetSelectedRowCoreInternal (int rowIndex, bool selected) {
5413 SetSelectedRowCore (rowIndex, selected);
5416 protected virtual void SetSelectedRowCore (int rowIndex, bool selected) {
5417 DataGridViewRow row = rows [rowIndex];
5419 row.SelectedInternal = selected;
5421 if (selected_rows == null)
5422 selected_rows = new DataGridViewSelectedRowCollection (this);
5424 if (!selected && selected_rows.Contains (row)) {
5425 selected_rows.InternalRemove (row);
5426 } else if (selected && !selected_rows.Contains (row)) {
5427 selected_rows.InternalAdd (row);
5433 protected override void WndProc (ref Message m)
5435 base.WndProc (ref m);
5438 internal void InternalOnCellClick (DataGridViewCellEventArgs e)
5443 internal void InternalOnCellContentClick (DataGridViewCellEventArgs e)
5445 OnCellContentClick (e);
5448 internal void InternalOnCellContentDoubleClick (DataGridViewCellEventArgs e)
5450 OnCellContentDoubleClick (e);
5453 internal void InternalOnCellValueChanged (DataGridViewCellEventArgs e)
5455 OnCellValueChanged (e);
5458 internal void InternalOnDataError (DataGridViewDataErrorEventArgs e)
5460 /////////////// false? ////////////
5461 OnDataError (false, e);
5464 internal void InternalOnMouseWheel (MouseEventArgs e)
5469 internal void OnHScrollBarScroll (object sender, ScrollEventArgs e)
5471 horizontalScrollingOffset = e.NewValue;
5474 for (int index = 0; index < Columns.Count; index++) {
5475 DataGridViewColumn col = Columns[index];
5477 if (e.NewValue < left + col.Width) {
5478 if (first_col_index != index) {
5479 first_col_index = index;
5491 internal void OnVScrollBarScroll (object sender, ScrollEventArgs e)
5493 verticalScrollingOffset = e.NewValue;
5494 if (Rows.Count == 0)
5499 for (int index = 0; index < Rows.Count; index++) {
5500 DataGridViewRow row = Rows[index];
5501 if (e.NewValue < top + row.Height) {
5502 if (first_row_index != index) {
5503 first_row_index = index;
5514 first_row_index = Rows.Count - DisplayedRowCount (false);
5519 internal void RaiseCellStyleChanged (DataGridViewCellEventArgs e) {
5520 OnCellStyleChanged(e);
5523 internal void OnColumnCollectionChanged (object sender, CollectionChangeEventArgs e) {
5525 case CollectionChangeAction.Add:
5526 OnColumnAddedInternal(new DataGridViewColumnEventArgs(e.Element as DataGridViewColumn));
5528 case CollectionChangeAction.Remove:
5529 OnColumnRemovedInternal(new DataGridViewColumnEventArgs(e.Element as DataGridViewColumn));
5531 case CollectionChangeAction.Refresh:
5536 // Resizes all columns according to their AutoResizeMode property.
5537 // First all the columns that aren't Filled are resized, then we resize all the Filled columns.
5538 internal void AutoResizeColumnsInternal ()
5540 for (int i = 0; i < Columns.Count; i++)
5541 AutoResizeColumnInternal (i, Columns [i].InheritedAutoSizeMode);
5543 AutoFillColumnsInternal ();
5546 internal void AutoFillColumnsInternal ()
5548 float totalFillWeight = 0;
5549 int FillCount = 0; // The number of columns that has AutoSizeMode.Fill set
5550 int spaceLeft = ClientSize.Width - (verticalScrollBar.VisibleInternal ? verticalScrollBar.Width : 0);
5552 if (RowHeadersVisible) {
5553 spaceLeft -= RowHeadersWidth;
5555 spaceLeft -= BorderWidth * 2;
5557 int [] fixed_widths = new int [Columns.Count];
5558 int [] new_widths = new int [Columns.Count];
5559 bool fixed_any = false;
5561 for (int i = 0; i < Columns.Count; i++) {
5562 DataGridViewColumn col = Columns [i];
5564 switch (col.InheritedAutoSizeMode) {
5565 case DataGridViewAutoSizeColumnMode.Fill:
5567 totalFillWeight += col.FillWeight;
5569 case DataGridViewAutoSizeColumnMode.AllCellsExceptHeader:
5570 case DataGridViewAutoSizeColumnMode.AllCells:
5571 case DataGridViewAutoSizeColumnMode.DisplayedCells:
5572 case DataGridViewAutoSizeColumnMode.DisplayedCellsExceptHeader:
5573 case DataGridViewAutoSizeColumnMode.None:
5574 case DataGridViewAutoSizeColumnMode.NotSet:
5575 spaceLeft -= Columns [i].Width;
5580 spaceLeft = Math.Max (0, spaceLeft);
5584 for (int i = 0; i < columns.Count; i++) {
5585 DataGridViewColumn col = Columns [i];
5588 if (col.InheritedAutoSizeMode != DataGridViewAutoSizeColumnMode.Fill)
5591 if (fixed_widths [i] != 0)
5594 width = (totalFillWeight == 0) ? 0 : (int) Math.Round (spaceLeft * (col.FillWeight / totalFillWeight), 0);
5599 if (width < col.MinimumWidth) {
5600 width = col.MinimumWidth;
5601 fixed_widths [i] = width;
5604 totalFillWeight -= col.FillWeight;
5607 new_widths [i] = width;
5609 } while (fixed_any);
5611 for (int i = 0; i < columns.Count; i++) {
5612 if (Columns [i].InheritedAutoSizeMode != DataGridViewAutoSizeColumnMode.Fill)
5615 Columns [i].Width = new_widths [i];
5619 internal void AutoResizeColumnInternal (int columnIndex, DataGridViewAutoSizeColumnMode mode)
5621 // http://msdn2.microsoft.com/en-us/library/ms171605.aspx
5624 DataGridViewColumn col = Columns [columnIndex];
5627 case DataGridViewAutoSizeColumnMode.Fill:
5629 case DataGridViewAutoSizeColumnMode.AllCellsExceptHeader:
5630 case DataGridViewAutoSizeColumnMode.AllCells:
5631 case DataGridViewAutoSizeColumnMode.DisplayedCells:
5632 case DataGridViewAutoSizeColumnMode.DisplayedCellsExceptHeader:
5633 size = Math.Max (CalculateColumnCellWidth (columnIndex, col.InheritedAutoSizeMode),
5634 col.HeaderCell.ContentBounds.Width);
5636 case DataGridViewAutoSizeColumnMode.ColumnHeader:
5637 size = col.HeaderCell.ContentBounds.Width;
5646 if (size < col.MinimumWidth)
5647 size = col.MinimumWidth;
5652 internal int CalculateColumnCellWidth (int index, DataGridViewAutoSizeColumnMode mode)
5656 bool only_visible = false;
5658 if (mode == DataGridViewAutoSizeColumnMode.DisplayedCellsExceptHeader ||
5659 mode == DataGridViewAutoSizeColumnMode.AllCellsExceptHeader)
5662 only_visible = (mode == DataGridViewAutoSizeColumnMode.DisplayedCells || mode == DataGridViewAutoSizeColumnMode.DisplayedCellsExceptHeader);
5664 for (int i = first_row; i < Rows.Count; i++) {
5666 Rectangle row_rect = this.GetRowDisplayRectangle (i, false);
5667 if (!ClientRectangle.IntersectsWith (row_rect))
5671 int cell_width = Rows[i].Cells[index].PreferredSize.Width;
5673 result = Math.Max (result, cell_width);
5679 Rectangle GetHeaderCellBounds (DataGridViewHeaderCell cell)
5681 Rectangle bounds = new Rectangle (ClientRectangle.Location, cell.Size);
5682 if (cell is DataGridViewColumnHeaderCell) {
5683 if (RowHeadersVisible)
5684 bounds.X += RowHeadersWidth;
5685 List<DataGridViewColumn> sortedColumns = columns.ColumnDisplayIndexSortedArrayList;
5686 for (int index = first_col_index; index < sortedColumns.Count; index++) {
5687 DataGridViewColumn column = sortedColumns [index];
5688 if (column.Index == cell.ColumnIndex)
5690 bounds.X += column.Width;
5693 if (ColumnHeadersVisible)
5694 bounds.Y += ColumnHeadersHeight;
5695 for (int index = first_row_index; index < Rows.Count; index++) {
5696 DataGridViewRow row = GetRowInternal (index);
5697 if (row.HeaderCell == cell)
5699 bounds.Y += row.Height;
5705 internal void PrepareEditingRow (bool cell_changed, bool column_changed)
5709 show = ColumnCount > 0 && AllowUserToAddRows;
5711 if (!show && editing_row != null) {
5712 Rows.RemoveInternal (editing_row);
5715 if (editing_row != null) {
5717 // The row changed, it's no longer an editing row.
5719 } else if (column_changed) {
5720 // The number of columns has changed, we need a new editing row.
5721 Rows.RemoveInternal (editing_row);
5725 if (editing_row == null) {
5726 editing_row = RowTemplateFull;
5727 Rows.AddInternal (editing_row, false);
5734 internal DataGridViewRow EditingRow {
5735 get { return editing_row; }
5738 private void BindIList (IList list) {
5739 if (autoGenerateColumns) {
5740 // Stuff from a DataSet
5741 if (list is DataView) {
5742 DataView dataView = (DataView) list;
5743 DataTable table = dataView.Table;
5745 foreach (DataColumn dataColumn in table.Columns) {
5746 DataGridViewColumn col = CreateColumnByType (dataColumn.DataType);
5748 col.Name = dataColumn.ColumnName;
5749 col.DataPropertyName = dataColumn.ColumnName;
5750 col.SetIsDataBound (true);
5751 col.ValueType = dataColumn.DataType;
5752 col.AutoGenerated = true;
5757 // Its a generic something or other, like a BindingList<T>, so
5758 // we can figure out the type from the generic type
5759 else if (list.GetType ().GetGenericArguments ().Length > 0) {
5760 GenerateColumnsFromType (list.GetType ().GetGenericArguments ()[0]);
5762 // Its a normal array/collection type thing
5763 else if (list.GetType ().IsArray) {
5764 GenerateColumnsFromType (list.GetType ().GetElementType ());
5765 } else if (list is BindingSource && (list as BindingSource).item_type != null) {
5766 foreach (PropertyDescriptor property in TypeDescriptor.GetProperties ((list as BindingSource).item_type)) {
5767 DataGridViewColumn col = CreateColumnByType (property.PropertyType);
5768 col.Name = property.DisplayName;
5769 col.ReadOnly = property.IsReadOnly;
5770 col.AutoGenerated = true;
5774 AllowUserToAddRows = (list as BindingSource).AllowNew;
5778 // Subscribe to the dataset's change notification
5779 if (list is DataView) {
5780 (list as DataView).ListChanged += OnListChanged;
5781 (list as DataView).Table.ColumnChanged += OnTableColumnChanged;
5782 (list as DataView).Table.TableCleared += OnTableCleared;
5786 foreach (object element in list)
5787 AddBoundRow (element);
5790 private void OnBindingSourceDataSourceChanged (object sender, EventArgs args)
5796 private void AddBoundRow (object element)
5798 // Don't add rows if there are no columns
5799 if (ColumnCount == 0)
5802 DataGridViewRow row = (DataGridViewRow)RowTemplateFull;
5803 rows.InternalAdd (row);
5805 PropertyDescriptorCollection properties = TypeDescriptor.GetProperties (element);
5807 foreach (PropertyDescriptor property in properties) {
5808 if (property.PropertyType == typeof (IBindingList))
5811 // We do it this way because there may not be a column
5812 // for every cell, ignore cells with no column
5813 DataGridViewCell cell = row.Cells.GetBoundCell (property.Name);
5818 cell.valuex = property.GetValue (element);
5819 cell.valueType = property.PropertyType;
5823 private void GenerateColumnsFromType (Type type)
5825 foreach (PropertyDescriptor property in TypeDescriptor.GetProperties (type)) {
5826 // This keeps out things like arrays
5827 if ((typeof(ICollection).IsAssignableFrom (property.PropertyType)))
5830 DataGridViewColumn col = CreateColumnByType (property.PropertyType);
5831 col.Name = property.DisplayName;
5832 col.DataPropertyName = property.DisplayName;
5833 col.ReadOnly = property.IsReadOnly;
5834 col.SetIsDataBound (true);
5835 col.ValueType = property.PropertyType;
5836 col.AutoGenerated = true;
5841 private DataGridViewColumn CreateColumnByType (Type type)
5843 if (type == typeof (bool))
5844 return new DataGridViewCheckBoxColumn ();
5846 return new DataGridViewTextBoxColumn ();
5849 private void ClearBinding ()
5851 columns.ClearAutoGeneratedColumns ();
5853 PrepareEditingRow (false, true);
5855 if (dataSource != null) {
5856 if (dataSource is DataSet) {
5857 (dataSource as DataSet).Tables.CollectionChanged -= OnDataSetTableChanged;
5859 DataTable dt = (dataSource as DataSet).Tables[dataMember];
5862 DataView dv = dt.DefaultView;
5865 (dv as DataView).Table.ColumnChanged -= OnTableColumnChanged;
5866 (dv as DataView).ListChanged -= OnListChanged;
5869 } else if (dataSource is DataView) {
5870 (dataSource as DataView).ListChanged -= OnListChanged;
5871 (dataSource as DataView).Table.ColumnChanged -= OnTableColumnChanged;
5872 } else if (dataSource is DataTable)
5873 ((dataSource as IListSource).GetList () as DataView).ListChanged -= OnListChanged;
5875 if (dataSource is IBindingList)
5876 (dataSource as IBindingList).ListChanged -= OnListChanged;
5877 if (dataSource is BindingSource)
5878 (dataSource as BindingSource).DataSourceChanged -= OnBindingSourceDataSourceChanged;
5882 private void DoBinding ()
5884 /* 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:
5885 - the System.Collections.IList interface, including one-dimensional arrays.
5886 - the System.ComponentModel.IListSource interface, such as the System.Data.DataTable and System.Data.DataSet classes.
5887 - the System.ComponentModel.IBindingList interface, such as the System.ComponentModel.Collections.BindingList<> class.
5888 - the System.ComponentModel.IBindingListView interface, such as the System.Windows.Forms.BindingSource class.
5891 if (dataSource != null) {
5892 object value = dataSource;
5895 if (value is DataSet && string.IsNullOrEmpty (dataMember)) {
5899 if (value is DataSet) {
5900 (value as DataSet).Tables.CollectionChanged += OnDataSetTableChanged;
5901 value = (value as DataSet).Tables[dataMember];
5904 if (value is BindingSource)
5905 BindBindingSource (value as BindingSource);
5906 else if (value is IBindingListView)
5907 BindIBindingListView (value as IBindingListView);
5908 else if (value is IBindingList)
5909 BindIBindingList (value as IBindingList);
5910 else if (value is IList)
5911 BindIList (value as IList);
5912 else if (value is IListSource)
5913 BindIListSource (value as IListSource);
5915 OnDataBindingComplete (new DataGridViewBindingCompleteEventArgs (ListChangedType.Reset));
5918 if (Rows.Count > 0 && Columns.Count > 0)
5919 MoveCurrentCell (0, 0, true, false, false, false);
5924 private void BindBindingSource (BindingSource bindingSource)
5926 BindIList (bindingSource.List);
5927 bindingSource.ListChanged += OnBindingSourceDataSourceChanged;
5928 bindingSource.DataSourceChanged += OnBindingSourceDataSourceChanged;
5931 private void BindIListSource (IListSource list) {
5932 BindIList (list.GetList());
5935 private void BindIBindingList (IBindingList list) {
5937 list.ListChanged += OnListChanged;
5940 private void BindIBindingListView (IBindingListView list) {
5944 private void MoveCurrentCell (int x, int y, bool select, bool isControl, bool isShift, bool scroll)
5946 SetCurrentCellAddressCore (x, y, true, false, false);
5948 bool full_row_selected = Rows.SharedRow(CurrentCellAddress.Y).Selected;
5949 bool full_col_selected = Columns[CurrentCellAddress.X].Selected;
5952 DataGridViewSelectionMode mode = selectionMode;
5954 // If we are row header select and we clicked a row header, use full row
5955 if (mode == DataGridViewSelectionMode.RowHeaderSelect && (x == -1 || (full_row_selected && CurrentCellAddress.X == x)))
5956 mode = DataGridViewSelectionMode.FullRowSelect;
5957 else if (mode == DataGridViewSelectionMode.RowHeaderSelect)
5958 mode = DataGridViewSelectionMode.CellSelect;
5960 // If we are col header select and we clicked a col header, use full col
5961 if (mode == DataGridViewSelectionMode.ColumnHeaderSelect && (y == -1 || (full_col_selected && CurrentCellAddress.Y == y)))
5962 mode = DataGridViewSelectionMode.FullColumnSelect;
5963 else if (mode == DataGridViewSelectionMode.ColumnHeaderSelect)
5964 mode = DataGridViewSelectionMode.CellSelect;
5966 // If the current cell isn't visible, scroll to it
5968 int disp_x = ColumnIndexToDisplayIndex (x);
5970 if (disp_x < first_col_index) {
5974 delta_x = horizontalScrollBar.Value;
5976 for (int i = disp_x; i < first_col_index; i++)
5977 delta_x += Columns[ColumnDisplayIndexToIndex (i)].Width;
5979 horizontalScrollBar.SafeValueSet (horizontalScrollBar.Value - delta_x);
5980 OnHScrollBarScroll (this, new ScrollEventArgs (ScrollEventType.ThumbPosition, horizontalScrollBar.Value));
5984 int displayedRowsCount = DisplayedRowCount (false);
5987 if (disp_y < first_row_index) {
5989 delta_y = verticalScrollBar.Value;
5991 for (int i = disp_y; i < first_row_index; i++)
5992 delta_y += GetRowInternal (i).Height;
5994 verticalScrollBar.SafeValueSet (verticalScrollBar.Value - delta_y);
5995 OnVScrollBarScroll (this, new ScrollEventArgs (ScrollEventType.ThumbPosition, verticalScrollBar.Value));
5996 } else if (disp_y > first_row_index + displayedRowsCount - 1) {
5997 if (disp_y == Rows.Count - 1)
5998 delta_y = verticalScrollBar.Maximum - verticalScrollBar.Value;
6000 for (int i = first_row_index + displayedRowsCount - 1; i < disp_y; i++)
6001 delta_y += GetRowInternal (i).Height;
6003 verticalScrollBar.SafeValueSet (verticalScrollBar.Value + delta_y);
6004 OnVScrollBarScroll (this, new ScrollEventArgs (ScrollEventType.ThumbPosition, verticalScrollBar.Value));
6011 // Clear old selection unless multi-selecting
6016 case DataGridViewSelectionMode.CellSelect:
6017 SetSelectedCellCore (x, y, true);
6019 case DataGridViewSelectionMode.FullRowSelect:
6020 SetSelectedRowCore (y, true);
6022 case DataGridViewSelectionMode.FullColumnSelect:
6023 SetSelectedColumnCore (x, true);
6030 private int ColumnIndexToDisplayIndex (int index)
6032 return Columns[index].DisplayIndex;
6035 private int ColumnDisplayIndexToIndex (int index)
6037 return Columns.ColumnDisplayIndexSortedArrayList[index].Index;
6040 private void OnListChanged (object sender, ListChangedEventArgs args)
6042 switch (args.ListChangedType) {
6043 case ListChangedType.ItemAdded:
6044 AddBoundRow ((sender as IBindingList)[args.NewIndex]);
6046 case ListChangedType.ItemDeleted:
6047 Rows.RemoveAt (args.NewIndex);
6058 private void OnTableColumnChanged (object sender, DataColumnChangeEventArgs e)
6064 private void OnDataSetTableChanged (object sender, CollectionChangeEventArgs e)
6070 private void OnTableCleared (object sender, DataTableClearEventArgs e)
6076 private bool MouseOverColumnResize (int col, int mousex)
6078 if (!allowUserToResizeColumns)
6081 Rectangle col_bounds = GetCellDisplayRectangle (col, 0, false);
6083 if (mousex >= col_bounds.Right - 4 && mousex <= col_bounds.Right)
6089 private bool MouseOverRowResize (int row, int mousey)
6091 if (!allowUserToResizeRows)
6094 Rectangle row_bounds = GetCellDisplayRectangle (0, row, false);
6096 if (mousey >= row_bounds.Bottom - 4 && mousey <= row_bounds.Bottom)
6102 private void DrawVerticalResizeLine (int x)
6104 Rectangle splitter = new Rectangle (x, Bounds.Y + 3 + (ColumnHeadersVisible ? ColumnHeadersHeight : 0), 1, Bounds.Height - 3 - (ColumnHeadersVisible ? ColumnHeadersHeight : 0));
6105 XplatUI.DrawReversibleRectangle (Handle, splitter, 2);
6108 private void DrawHorizontalResizeLine (int y)
6110 Rectangle splitter = new Rectangle (Bounds.X + 3 + (RowHeadersVisible ? RowHeadersWidth : 0), y, Bounds.Width - 3 + (RowHeadersVisible ? RowHeadersWidth : 0), 1);
6111 XplatUI.DrawReversibleRectangle (Handle, splitter, 2);
6114 #region Stuff for ToolTips
6115 private void MouseEnteredErrorIcon (DataGridViewCell item)
6117 tooltip_currently_showing = item;
6118 ToolTipTimer.Start ();
6121 private void MouseLeftErrorIcon (DataGridViewCell item)
6123 ToolTipTimer.Stop ();
6124 ToolTipWindow.Hide (this);
6125 tooltip_currently_showing = null;
6128 private Timer ToolTipTimer {
6130 if (tooltip_timer == null) {
6131 tooltip_timer = new Timer ();
6132 tooltip_timer.Enabled = false;
6133 tooltip_timer.Interval = 500;
6134 tooltip_timer.Tick += new EventHandler (ToolTipTimer_Tick);
6137 return tooltip_timer;
6141 private ToolTip ToolTipWindow {
6143 if (tooltip_window == null)
6144 tooltip_window = new ToolTip ();
6146 return tooltip_window;
6150 private void ToolTipTimer_Tick (object o, EventArgs args)
6152 string tooltip = tooltip_currently_showing.ErrorText;
6154 if (!string.IsNullOrEmpty (tooltip))
6155 ToolTipWindow.Present (this, tooltip);
6157 ToolTipTimer.Stop ();
6161 private class ColumnSorter : IComparer
6167 public ColumnSorter (DataGridViewColumn column, ListSortDirection direction, bool numeric)
6169 this.column = column.Index;
6170 this.numeric_sort = numeric;
6172 if (direction == ListSortDirection.Descending)
6173 this.direction = -1;
6176 #region IComparer Members
6177 public int Compare (object x, object y)
6179 DataGridViewRow row1 = (DataGridViewRow)x;
6180 DataGridViewRow row2 = (DataGridViewRow)y;
6182 if (row1.Cells[column].ValueType == typeof (DateTime) && row2.Cells[column].ValueType == typeof (DateTime))
6183 return DateTime.Compare ((DateTime)row1.Cells[column].valuex, (DateTime)row2.Cells[column].valuex) * direction;
6185 object val1 = row1.Cells[column].FormattedValue;
6186 object val2 = row2.Cells[column].FormattedValue;
6188 if (val1 == null && val2 == null)
6193 return -1 * direction;
6196 return (int)(double.Parse (val1.ToString ()) - double.Parse (val2.ToString ())) * direction;
6198 return string.Compare (val1.ToString (), val2.ToString ()) * direction;
6203 public sealed class HitTestInfo {
6205 public static readonly HitTestInfo Nowhere = new HitTestInfo(-1, -1, -1, -1, DataGridViewHitTestType.None);
6207 private int columnIndex;
6208 private int columnX;
6209 private int rowIndex;
6211 private DataGridViewHitTestType type;
6213 internal HitTestInfo (int columnIndex, int columnX, int rowIndex, int rowY, DataGridViewHitTestType type) {
6214 this.columnIndex = columnIndex;
6215 this.columnX = columnX;
6216 this.rowIndex = rowIndex;
6221 public int ColumnIndex {
6222 get { return columnIndex; }
6225 public int ColumnX {
6226 get { return columnX; }
6229 public int RowIndex {
6230 get { return rowIndex; }
6234 get { return rowY; }
6237 public DataGridViewHitTestType Type {
6238 get { return type; }
6241 public override bool Equals (object value) {
6242 if (value is HitTestInfo) {
6243 HitTestInfo aux = (HitTestInfo) value;
6244 if (aux.columnIndex == columnIndex && aux.columnX == columnX && aux.rowIndex == rowIndex && aux.rowY == rowY && aux.type == type) {
6251 public override int GetHashCode () {
6252 return base.GetHashCode();
6255 public override string ToString () {
6256 return string.Format ("Type:{0}, Column:{1}, Row:{2}", type, columnIndex, rowIndex);
6261 [ComVisible (false)]
6262 public class DataGridViewControlCollection : Control.ControlCollection
6264 private DataGridView owner;
6266 public DataGridViewControlCollection (DataGridView owner) : base (owner)
6271 public override void Clear ()
6274 // This is severely buggy, just as MS' implementation is.
6276 for (int i = 0; i < Count; i++) {
6281 public void CopyTo (Control [] array, int index)
6283 base.CopyTo (array, index);
6286 public void Insert (int index, Control value)
6288 throw new NotSupportedException ();
6291 public override void Remove (Control value)
6293 if (value == owner.horizontalScrollBar)
6296 if (value == owner.verticalScrollBar)
6299 if (value == owner.editingControl)
6302 base.Remove (value);
6305 internal void RemoveInternal (Control value)
6307 base.Remove (value);
6313 [ComVisibleAttribute(true)]
6314 protected class DataGridViewAccessibleObject : ControlAccessibleObject {
6316 public DataGridViewAccessibleObject (DataGridView owner) : base (owner){
6319 public override AccessibleRole Role {
6320 get { return base.Role; }
6323 public override string Name {
6324 get { return base.Name; }
6327 public override AccessibleObject GetChild (int index) {
6328 return base.GetChild(index);
6331 public override int GetChildCount () {
6332 return base.GetChildCount();
6335 public override AccessibleObject GetFocused () {
6336 return base.GetFocused();
6339 public override AccessibleObject GetSelected () {
6340 return base.GetSelected();
6343 public override AccessibleObject HitTest (int x, int y) {
6344 return base.HitTest(x, y);
6347 public override AccessibleObject Navigate( AccessibleNavigation navigationDirection) {
6348 return base.Navigate(navigationDirection);
6354 protected class DataGridViewTopRowAccessibleObject : AccessibleObject
6356 #region Constructors
6357 public DataGridViewTopRowAccessibleObject ()
6361 public DataGridViewTopRowAccessibleObject (DataGridView owner)
6367 #region Public Methods
6368 public override AccessibleObject GetChild (int index)
6370 return base.GetChild (index);
6373 public override int GetChildCount ()
6375 return base.GetChildCount ();
6378 public override AccessibleObject Navigate (AccessibleNavigation navigationDirection)
6380 return base.Navigate (navigationDirection);
6384 #region Public Properties
6385 public override Rectangle Bounds {
6386 get { return base.Bounds; }
6389 public override string Name {
6390 get { return base.Name; }
6393 public DataGridView Owner {
6394 get { return (DataGridView)owner; }
6397 throw new InvalidOperationException ("owner has already been set");
6403 public override AccessibleObject Parent {
6404 get { return base.Parent; }
6407 public override AccessibleRole Role {
6408 get { return base.Role; }
6411 public override string Value {
6412 get { return base.Value; }