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>
24 // Ivan N. Zlatev <contact@i-nz.net>
30 using System.ComponentModel;
31 using System.Runtime.InteropServices;
33 using System.Reflection;
34 using System.Collections;
36 using System.Collections.Generic;
38 namespace System.Windows.Forms {
40 [ComVisibleAttribute(true)]
41 [ClassInterfaceAttribute(ClassInterfaceType.AutoDispatch)]
42 [Designer("System.Windows.Forms.Design.DataGridViewDesigner, " + Consts.AssemblySystem_Design, "System.ComponentModel.Design.IDesigner")]
43 [Editor("System.Windows.Forms.Design.DataGridViewComponentEditor, " + Consts.AssemblySystem_Design, typeof (System.ComponentModel.ComponentEditor))]
44 [ComplexBindingProperties ("DataSource", "DataMember")]
45 [DefaultEvent ("CellContentClick")]
46 [Docking (DockingBehavior.Ask)]
47 public class DataGridView : Control, ISupportInitialize, IBindableComponent, IDropTarget
50 private DataGridViewAdvancedBorderStyle adjustedTopLeftHeaderBorderStyle;
51 private DataGridViewAdvancedBorderStyle advancedCellBorderStyle;
52 private DataGridViewAdvancedBorderStyle advancedColumnHeadersBorderStyle;
53 private DataGridViewAdvancedBorderStyle advancedRowHeadersBorderStyle;
54 private bool allowUserToAddRows;
55 private bool allowUserToDeleteRows;
56 private bool allowUserToOrderColumns;
57 private bool allowUserToResizeColumns;
58 private bool allowUserToResizeRows;
59 private DataGridViewCellStyle alternatingRowsDefaultCellStyle;
60 private Point anchor_cell;
61 private bool autoGenerateColumns;
62 private bool autoSize;
63 private DataGridViewAutoSizeColumnsMode autoSizeColumnsMode;
64 private DataGridViewAutoSizeRowsMode autoSizeRowsMode;
65 private Color backColor;
66 private Color backgroundColor;
67 private Image backgroundImage;
68 private BorderStyle borderStyle;
69 private DataGridViewCellBorderStyle cellBorderStyle;
70 private DataGridViewClipboardCopyMode clipboardCopyMode;
71 private DataGridViewHeaderBorderStyle columnHeadersBorderStyle;
72 private DataGridViewCellStyle columnHeadersDefaultCellStyle;
73 private int columnHeadersHeight;
74 private DataGridViewColumnHeadersHeightSizeMode columnHeadersHeightSizeMode;
75 private bool columnHeadersVisible;
76 private DataGridViewColumnCollection columns;
77 private DataGridViewCell currentCell;
78 private Point currentCellAddress;
79 private DataGridViewRow currentRow;
80 private string dataMember;
81 private object dataSource;
82 private DataGridViewCellStyle defaultCellStyle;
83 //private Control editingControl;
84 private DataGridViewEditMode editMode;
85 private bool enableHeadersVisualStyles = true;
86 private DataGridViewCell firstDisplayedCell;
87 private int firstDisplayedScrollingColumnHiddenWidth;
88 private int firstDisplayedScrollingColumnIndex;
89 private int firstDisplayedScrollingRowIndex;
90 private Color gridColor = Color.FromKnownColor(KnownColor.ControlDark);
91 private int horizontalScrollingOffset;
92 private DataGridViewCell hover_cell = null;
93 private bool isCurrentCellDirty;
94 //private bool isCurrentRowDirty;
95 private bool multiSelect;
96 private bool readOnly;
97 private DataGridViewHeaderBorderStyle rowHeadersBorderStyle;
98 private DataGridViewCellStyle rowHeadersDefaultCellStyle;
99 private bool rowHeadersVisible;
100 private int rowHeadersWidth;
101 private DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode;
102 private DataGridViewRowCollection rows;
103 private DataGridViewCellStyle rowsDefaultCellStyle;
104 private DataGridViewRow rowTemplate;
105 private ScrollBars scrollBars;
106 private DataGridViewSelectionMode selectionMode;
107 private bool showCellErrors;
108 private bool showCellToolTips;
109 private bool showEditingIcon;
110 private bool showRowErrors;
111 private DataGridViewColumn sortedColumn = null;
112 private SortOrder sortOrder;
113 private bool standardTab;
114 private DataGridViewHeaderCell topLeftHeaderCell;
115 private Cursor userSetCursor;
116 private int verticalScrollingOffset;
117 private bool virtualMode;
118 private HScrollBar horizontalScrollBar;
119 private VScrollBar verticalScrollBar;
120 private Control editingControl;
121 private bool is_autogenerating_columns = false;
122 private bool is_binding = false;
123 private bool new_row_editing = false;
125 // These are used to implement selection behaviour with SHIFT pressed.
126 private int selected_row = -1;
127 private int selected_column = -1;
129 // Stuff for error Tooltips
130 private Timer tooltip_timer;
131 private ToolTip tooltip_window;
132 private DataGridViewCell tooltip_currently_showing;
134 private DataGridViewSelectedRowCollection selected_rows;
135 private DataGridViewSelectedColumnCollection selected_columns;
136 private DataGridViewRow editing_row;
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 currentCellAddress = new Point (-1, -1);
191 dataMember = String.Empty;
192 defaultCellStyle = new DataGridViewCellStyle();
193 defaultCellStyle.BackColor = SystemColors.Window;
194 defaultCellStyle.ForeColor = SystemColors.ControlText;
195 defaultCellStyle.SelectionBackColor = SystemColors.Highlight;
196 defaultCellStyle.SelectionForeColor = SystemColors.HighlightText;
197 defaultCellStyle.Font = this.Font;
198 defaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleLeft;
199 defaultCellStyle.WrapMode = DataGridViewTriState.False;
200 editMode = DataGridViewEditMode.EditOnKeystrokeOrF2;
201 firstDisplayedScrollingColumnHiddenWidth = 0;
202 isCurrentCellDirty = false;
205 rowHeadersBorderStyle = DataGridViewHeaderBorderStyle.Single;
206 rowHeadersDefaultCellStyle = (DataGridViewCellStyle) columnHeadersDefaultCellStyle.Clone ();
207 rowHeadersVisible = true;
208 rowHeadersWidth = 41;
209 rowHeadersWidthSizeMode = DataGridViewRowHeadersWidthSizeMode.EnableResizing;
210 rows = CreateRowsInstance();
211 rowsDefaultCellStyle = new DataGridViewCellStyle();
212 selectionMode = DataGridViewSelectionMode.RowHeaderSelect;
213 showCellErrors = true;
214 showEditingIcon = true;
215 scrollBars = ScrollBars.Both;
216 userSetCursor = Cursor.Current;
219 horizontalScrollBar = new HScrollBar();
220 horizontalScrollBar.Scroll += OnHScrollBarScroll;
221 horizontalScrollBar.Visible = false;
223 verticalScrollBar = new VScrollBar();
224 verticalScrollBar.Scroll += OnVScrollBarScroll;
225 verticalScrollBar.Visible = false;
227 Controls.AddRange (new Control[] {horizontalScrollBar, verticalScrollBar});
230 void ISupportInitialize.BeginInit ()
234 void ISupportInitialize.EndInit ()
241 [EditorBrowsable (EditorBrowsableState.Advanced)]
242 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
243 public virtual DataGridViewAdvancedBorderStyle AdjustedTopLeftHeaderBorderStyle {
244 get { return adjustedTopLeftHeaderBorderStyle; }
248 [EditorBrowsable (EditorBrowsableState.Advanced)]
249 public DataGridViewAdvancedBorderStyle AdvancedCellBorderStyle {
250 get { return advancedCellBorderStyle; }
254 [EditorBrowsable (EditorBrowsableState.Advanced)]
255 public DataGridViewAdvancedBorderStyle AdvancedColumnHeadersBorderStyle {
256 get { return advancedColumnHeadersBorderStyle; }
260 [EditorBrowsable (EditorBrowsableState.Advanced)]
261 public DataGridViewAdvancedBorderStyle AdvancedRowHeadersBorderStyle {
262 get { return advancedRowHeadersBorderStyle; }
265 [DefaultValue (true)]
266 public bool AllowUserToAddRows {
268 if (allowUserToAddRows && DataManager != null)
269 return DataManager.AllowNew;
270 return allowUserToAddRows;
273 if (allowUserToAddRows != value) {
274 allowUserToAddRows = value;
280 PrepareEditingRow (false, false);
282 OnAllowUserToAddRowsChanged(EventArgs.Empty);
288 [DefaultValue (true)]
289 public bool AllowUserToDeleteRows {
291 if (allowUserToDeleteRows && DataManager != null)
292 return DataManager.AllowRemove;
293 return allowUserToDeleteRows;
296 if (allowUserToDeleteRows != value) {
297 allowUserToDeleteRows = value;
298 OnAllowUserToDeleteRowsChanged(EventArgs.Empty);
303 [DefaultValue (false)]
304 public bool AllowUserToOrderColumns {
305 get { return allowUserToOrderColumns; }
307 if (allowUserToOrderColumns != value) {
308 allowUserToOrderColumns = value;
309 OnAllowUserToOrderColumnsChanged(EventArgs.Empty);
314 [DefaultValue (true)]
315 public bool AllowUserToResizeColumns {
316 get { return allowUserToResizeColumns; }
318 if (allowUserToResizeColumns != value) {
319 allowUserToResizeColumns = value;
320 OnAllowUserToResizeColumnsChanged(EventArgs.Empty);
325 [DefaultValue (true)]
326 public bool AllowUserToResizeRows {
327 get { return allowUserToResizeRows; }
329 if (allowUserToResizeRows != value) {
330 allowUserToResizeRows = value;
331 OnAllowUserToResizeRowsChanged(EventArgs.Empty);
336 public DataGridViewCellStyle AlternatingRowsDefaultCellStyle {
337 get { return alternatingRowsDefaultCellStyle; }
339 if (alternatingRowsDefaultCellStyle != value) {
340 alternatingRowsDefaultCellStyle = value;
341 OnAlternatingRowsDefaultCellStyleChanged(EventArgs.Empty);
348 [EditorBrowsable (EditorBrowsableState.Advanced)]
349 [DefaultValue (true)]
350 public bool AutoGenerateColumns {
351 get { return autoGenerateColumns; }
353 if (autoGenerateColumns != value) {
354 autoGenerateColumns = value;
355 OnAutoGenerateColumnsChanged(EventArgs.Empty);
360 public override bool AutoSize {
361 get { return autoSize; }
363 if (autoSize != value) {
365 //OnAutoSizeChanged(EventArgs.Empty);
370 [DefaultValue (DataGridViewAutoSizeColumnsMode.None)]
371 public DataGridViewAutoSizeColumnsMode AutoSizeColumnsMode {
372 get { return autoSizeColumnsMode; }
374 if (!Enum.IsDefined(typeof(DataGridViewAutoSizeColumnsMode), value)) {
375 throw new InvalidEnumArgumentException("Value is not valid DataGridViewAutoSizeColumnsMode.");
377 if (value == DataGridViewAutoSizeColumnsMode.ColumnHeader && columnHeadersVisible == false) {
378 foreach (DataGridViewColumn col in columns) {
379 if (col.AutoSizeMode == DataGridViewAutoSizeColumnMode.NotSet) {
380 throw new InvalidOperationException("Cant set this property to ColumnHeader in this DataGridView.");
384 if (value == DataGridViewAutoSizeColumnsMode.Fill) {
385 foreach (DataGridViewColumn col in columns) {
386 if (col.AutoSizeMode == DataGridViewAutoSizeColumnMode.NotSet) {
388 throw new InvalidOperationException("Cant set this property to Fill in this DataGridView.");
394 autoSizeColumnsMode = value;
395 AutoResizeColumns (value);
400 [DefaultValue (DataGridViewAutoSizeRowsMode.None)]
401 public DataGridViewAutoSizeRowsMode AutoSizeRowsMode {
402 get { return autoSizeRowsMode; }
404 if (autoSizeRowsMode != value) {
405 if (!Enum.IsDefined(typeof(DataGridViewAutoSizeRowsMode), value)) {
406 throw new InvalidEnumArgumentException("Value is not valid DataGridViewRowsMode.");
408 if ((value == DataGridViewAutoSizeRowsMode.AllHeaders || value == DataGridViewAutoSizeRowsMode.DisplayedHeaders) && rowHeadersVisible == false) {
409 throw new InvalidOperationException("Cant set this property to AllHeaders or DisplayedHeaders in this DataGridView.");
411 autoSizeRowsMode = value;
413 if (value == DataGridViewAutoSizeRowsMode.None)
414 foreach (DataGridViewRow row in Rows)
415 row.ResetToExplicitHeight ();
417 AutoResizeRows (value);
419 OnAutoSizeRowsModeChanged(new DataGridViewAutoSizeModeEventArgs(false));
421 ////////////////////////////////////////////////////////////////
427 [EditorBrowsable (EditorBrowsableState.Never)]
428 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
429 public override Color BackColor {
430 get { return backColor; }
432 if (backColor != value) {
434 OnBackColorChanged(EventArgs.Empty);
439 public Color BackgroundColor {
440 get { return backgroundColor; }
442 if (backgroundColor != value) {
443 if (value == Color.Empty) {
444 throw new ArgumentException("Cant set an Empty color.");
446 backgroundColor = value;
447 OnBackgroundColorChanged(EventArgs.Empty);
453 [EditorBrowsable (EditorBrowsableState.Never)]
454 public override Image BackgroundImage {
455 get { return backgroundImage; }
457 if (backgroundImage != value) {
458 backgroundImage = value;
459 OnBackgroundImageChanged(EventArgs.Empty);
465 [EditorBrowsable (EditorBrowsableState.Never)]
466 public override ImageLayout BackgroundImageLayout {
467 get { return base.BackgroundImageLayout; }
468 set { base.BackgroundImageLayout = value; }
471 [DefaultValue (BorderStyle.FixedSingle)]
472 public BorderStyle BorderStyle {
473 get { return borderStyle; }
475 if (borderStyle != value) {
476 if (!Enum.IsDefined(typeof(BorderStyle), value)) {
477 throw new InvalidEnumArgumentException("Invalid border style.");
480 OnBorderStyleChanged(EventArgs.Empty);
485 internal int BorderWidth {
487 switch (BorderStyle) {
488 case BorderStyle.Fixed3D:
490 case BorderStyle.FixedSingle:
492 case BorderStyle.None:
500 [DefaultValue (DataGridViewCellBorderStyle.Single)]
501 public DataGridViewCellBorderStyle CellBorderStyle {
502 get { return cellBorderStyle; }
504 if (cellBorderStyle != value) {
505 if (value == DataGridViewCellBorderStyle.Custom)
506 throw new ArgumentException ("CellBorderStyle cannot be set to Custom.");
508 cellBorderStyle = value;
510 DataGridViewAdvancedBorderStyle border = new DataGridViewAdvancedBorderStyle ();
512 switch (cellBorderStyle) {
513 case DataGridViewCellBorderStyle.Single:
514 border.All = DataGridViewAdvancedCellBorderStyle.Single;
516 case DataGridViewCellBorderStyle.Raised:
517 case DataGridViewCellBorderStyle.RaisedVertical:
518 border.Bottom = DataGridViewAdvancedCellBorderStyle.None;
519 border.Top = DataGridViewAdvancedCellBorderStyle.None;
520 border.Left = DataGridViewAdvancedCellBorderStyle.Outset;
521 border.Right = DataGridViewAdvancedCellBorderStyle.Outset;
523 case DataGridViewCellBorderStyle.Sunken:
524 border.All = DataGridViewAdvancedCellBorderStyle.Inset;
526 case DataGridViewCellBorderStyle.None:
527 border.All = DataGridViewAdvancedCellBorderStyle.None;
529 case DataGridViewCellBorderStyle.SingleVertical:
530 border.Bottom = DataGridViewAdvancedCellBorderStyle.None;
531 border.Top = DataGridViewAdvancedCellBorderStyle.None;
532 border.Left = DataGridViewAdvancedCellBorderStyle.None;
533 border.Right = DataGridViewAdvancedCellBorderStyle.Single;
535 case DataGridViewCellBorderStyle.SunkenVertical:
536 border.Bottom = DataGridViewAdvancedCellBorderStyle.None;
537 border.Top = DataGridViewAdvancedCellBorderStyle.None;
538 border.Left = DataGridViewAdvancedCellBorderStyle.Inset;
539 border.Right = DataGridViewAdvancedCellBorderStyle.Inset;
541 case DataGridViewCellBorderStyle.SingleHorizontal:
542 case DataGridViewCellBorderStyle.SunkenHorizontal:
543 border.Bottom = DataGridViewAdvancedCellBorderStyle.Inset;
544 border.Top = DataGridViewAdvancedCellBorderStyle.Inset;
545 border.Left = DataGridViewAdvancedCellBorderStyle.None;
546 border.Right = DataGridViewAdvancedCellBorderStyle.None;
548 case DataGridViewCellBorderStyle.RaisedHorizontal:
549 border.Bottom = DataGridViewAdvancedCellBorderStyle.Outset;
550 border.Top = DataGridViewAdvancedCellBorderStyle.Outset;
551 border.Left = DataGridViewAdvancedCellBorderStyle.None;
552 border.Right = DataGridViewAdvancedCellBorderStyle.None;
556 advancedCellBorderStyle = border;
558 OnCellBorderStyleChanged (EventArgs.Empty);
564 [DefaultValue (DataGridViewClipboardCopyMode.EnableWithAutoHeaderText)]
565 public DataGridViewClipboardCopyMode ClipboardCopyMode {
566 get { return clipboardCopyMode; }
567 set { clipboardCopyMode = value; }
571 [EditorBrowsable (EditorBrowsableState.Advanced)]
572 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
574 public int ColumnCount {
575 get { return columns.Count; }
578 throw new ArgumentOutOfRangeException("ColumnCount",
579 "ColumnCount must be >= 0.");
581 if (dataSource != null) {
582 throw new InvalidOperationException("Cant change column count if DataSource is set.");
584 if (value < columns.Count) {
585 for (int i = columns.Count -1; i >= value; i--) {
589 else if (value > columns.Count) {
590 for (int i = columns.Count; i < value; i++) {
591 DataGridViewTextBoxColumn col = new DataGridViewTextBoxColumn ();
599 [DefaultValue (DataGridViewHeaderBorderStyle.Raised)]
600 public DataGridViewHeaderBorderStyle ColumnHeadersBorderStyle {
601 get { return columnHeadersBorderStyle; }
603 if (columnHeadersBorderStyle != value) {
604 columnHeadersBorderStyle = value;
605 OnColumnHeadersBorderStyleChanged(EventArgs.Empty);
610 [AmbientValue (null)]
611 public DataGridViewCellStyle ColumnHeadersDefaultCellStyle {
612 get { return columnHeadersDefaultCellStyle; }
614 if (columnHeadersDefaultCellStyle != value) {
615 columnHeadersDefaultCellStyle = value;
616 OnColumnHeadersDefaultCellStyleChanged(EventArgs.Empty);
622 public int ColumnHeadersHeight {
623 get { return columnHeadersHeight; }
625 if (columnHeadersHeight != value) {
627 throw new ArgumentOutOfRangeException("ColumnHeadersHeight",
628 "Column headers height cant be less than 4.");
630 if (value > 32768 ) {
631 throw new ArgumentOutOfRangeException("ColumnHeadersHeight",
632 "Column headers height cannot be more than 32768.");
634 columnHeadersHeight = value;
635 OnColumnHeadersHeightChanged(EventArgs.Empty);
637 if (columnHeadersVisible)
643 [RefreshProperties (RefreshProperties.All)]
644 [DefaultValue (DataGridViewColumnHeadersHeightSizeMode.EnableResizing)]
645 public DataGridViewColumnHeadersHeightSizeMode ColumnHeadersHeightSizeMode {
646 get { return columnHeadersHeightSizeMode; }
648 if (columnHeadersHeightSizeMode != value) {
649 if (!Enum.IsDefined(typeof(DataGridViewColumnHeadersHeightSizeMode), value)) {
650 throw new InvalidEnumArgumentException("Value is not a valid DataGridViewColumnHeadersHeightSizeMode.");
652 columnHeadersHeightSizeMode = value;
653 OnColumnHeadersHeightSizeModeChanged(new DataGridViewAutoSizeModeEventArgs(false));
658 [DefaultValue (true)]
659 public bool ColumnHeadersVisible {
660 get { return columnHeadersVisible; }
662 if (columnHeadersVisible != value) {
663 columnHeadersVisible = value;
669 [MergableProperty (false)]
670 [Editor ("System.Windows.Forms.Design.DataGridViewColumnCollectionEditor, " + Consts.AssemblySystem_Design, typeof (System.Drawing.Design.UITypeEditor))]
671 [DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]
672 public DataGridViewColumnCollection Columns {
673 get { return columns; }
677 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
678 public DataGridViewCell CurrentCell {
679 get { return currentCell; }
681 /////////////////////////////////////////////////////
682 /// *** InvalidOperationException ***
683 /// Changes to the specified cell cannot be committed
684 /// to the data cache, or the new cell is in a hidden
686 /////////////////////////////////////////////////////
688 MoveCurrentCell (-1, -1, true, false, false, true);
689 else if (value.DataGridView != this)
690 throw new ArgumentException("The cell is not in this DataGridView.");
692 MoveCurrentCell (value.OwningColumn.Index, value.OwningRow.Index, true, false, false, true);
697 public Point CurrentCellAddress {
698 get { return currentCellAddress; }
702 public DataGridViewRow CurrentRow {
704 if (currentCell != null)
705 return currentCell.OwningRow;
711 [Editor ("System.Windows.Forms.Design.DataMemberListEditor, " + Consts.AssemblySystem_Design, typeof (System.Drawing.Design.UITypeEditor))]
712 public string DataMember {
713 get { return dataMember; }
715 if (dataMember != value) {
717 if (BindingContext != null)
719 OnDataMemberChanged(EventArgs.Empty);
724 [RefreshProperties (RefreshProperties.Repaint)]
725 [DefaultValue (null)]
726 [AttributeProvider (typeof (IListSource))]
727 public object DataSource {
728 get { return dataSource; }
730 /* 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:
731 - the System.Collections.IList interface, including one-dimensional arrays.
732 - the System.ComponentModel.IListSource interface, such as the System.Data.DataTable and System.Data.DataSet classes.
733 - the System.ComponentModel.IBindingList interface, such as the System.ComponentModel.Collections.BindingList<> class.
734 - the System.ComponentModel.IBindingListView interface, such as the System.Windows.Forms.BindingSource class.
736 if (!(value == null || value is IList || value is IListSource || value is IBindingList || value is IBindingListView))
737 throw new NotSupportedException ("Type cannot be bound.");
739 if (value != DataSource) {
740 if (IsHandleCreated && value != null && BindingContext != null && BindingContext[value] != null)
741 DataMember = String.Empty;
745 // Do not set dataSource prior to te BindingContext check because there is some lazy initialization
746 // code which might result in double call to ReBind here and in OnBindingContextChanged
747 if (BindingContext != null) {
754 OnDataSourceChanged (EventArgs.Empty);
759 internal CurrencyManager DataManager {
761 if (DataSource != null && BindingContext != null) {
762 string dataMember = DataMember;
763 if (dataMember == null)
764 dataMember = String.Empty;
765 return (CurrencyManager) this.BindingContext[DataSource, dataMember];
771 [AmbientValue (null)]
772 public DataGridViewCellStyle DefaultCellStyle {
773 get { return defaultCellStyle; }
775 if (defaultCellStyle != value) {
776 defaultCellStyle = value;
777 OnDefaultCellStyleChanged(EventArgs.Empty);
782 public override Rectangle DisplayRectangle {
783 get { return base.DisplayRectangle; }
787 [EditorBrowsable (EditorBrowsableState.Advanced)]
788 public Control EditingControl {
790 return editingControl;
795 [EditorBrowsable (EditorBrowsableState.Advanced)]
796 public Panel EditingPanel {
797 get { throw new NotImplementedException(); }
800 [DefaultValue (DataGridViewEditMode.EditOnKeystrokeOrF2)]
801 public DataGridViewEditMode EditMode {
802 get { return editMode; }
804 if (editMode != value) {
806 OnEditModeChanged(EventArgs.Empty);
811 [DefaultValue (true)]
812 public bool EnableHeadersVisualStyles {
813 get { return enableHeadersVisualStyles; }
814 set { enableHeadersVisualStyles = value; }
817 internal DataGridViewHeaderCell EnteredHeaderCell {
818 get { return entered_header_cell; }
820 if (entered_header_cell == value)
822 if (ThemeEngine.Current.DataGridViewHeaderCellHasHotStyle (this)) {
823 Region area_to_invalidate = new Region ();
824 area_to_invalidate.MakeEmpty ();
825 if (entered_header_cell != null)
826 area_to_invalidate.Union (GetHeaderCellBounds (entered_header_cell));
827 entered_header_cell = value;
828 if (entered_header_cell != null)
829 area_to_invalidate.Union (GetHeaderCellBounds (entered_header_cell));
830 Invalidate (area_to_invalidate);
831 area_to_invalidate.Dispose ();
833 entered_header_cell = value;
838 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
839 public DataGridViewCell FirstDisplayedCell {
840 get { return firstDisplayedCell; }
842 if (value.DataGridView != this) {
843 throw new ArgumentException("The cell is not in this DataGridView.");
845 firstDisplayedCell = value;
850 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
851 [EditorBrowsable (EditorBrowsableState.Advanced)]
852 public int FirstDisplayedScrollingColumnHiddenWidth {
853 get { return firstDisplayedScrollingColumnHiddenWidth; }
857 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
858 public int FirstDisplayedScrollingColumnIndex {
859 get { return firstDisplayedScrollingColumnIndex; }
860 set { firstDisplayedScrollingColumnIndex = value; }
864 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
865 public int FirstDisplayedScrollingRowIndex {
866 get { return firstDisplayedScrollingRowIndex; }
867 set { firstDisplayedScrollingRowIndex = value; }
871 [EditorBrowsable (EditorBrowsableState.Advanced)]
872 public override Font Font {
873 get { return base.Font; }
874 set { base.Font = value; }
878 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
879 [EditorBrowsable (EditorBrowsableState.Advanced)]
880 public override Color ForeColor {
881 get { return base.ForeColor; }
882 set { base.ForeColor = value; }
885 public Color GridColor {
886 get { return gridColor; }
888 if (gridColor != value) {
889 if (value == Color.Empty) {
890 throw new ArgumentException("Cant set an Empty color.");
893 OnGridColorChanged(EventArgs.Empty);
899 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
900 public int HorizontalScrollingOffset {
901 get { return horizontalScrollingOffset; }
902 set { horizontalScrollingOffset = value; }
906 public bool IsCurrentCellDirty {
907 get { return isCurrentCellDirty; }
911 public bool IsCurrentCellInEditMode {
913 if (currentCell == null) {
916 return currentCell.IsInEditMode;
921 public bool IsCurrentRowDirty {
924 return IsCurrentCellDirty;
926 QuestionEventArgs args = new QuestionEventArgs ();
927 OnRowDirtyStateNeeded (args);
928 return args.Response;
933 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
934 public DataGridViewCell this [int columnIndex, int rowIndex] {
935 get { return rows[rowIndex].Cells[columnIndex]; }
936 set { rows[rowIndex].Cells[columnIndex] = value; }
940 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
941 public DataGridViewCell this [string columnName, int rowIndex] {
943 int columnIndex = -1;
944 foreach (DataGridViewColumn col in columns) {
945 if (col.Name == columnName) {
946 columnIndex = col.Index;
950 return this[columnIndex, rowIndex];
953 int columnIndex = -1;
954 foreach (DataGridViewColumn col in columns) {
955 if (col.Name == columnName) {
956 columnIndex = col.Index;
960 this[columnIndex, rowIndex] = value;
964 [DefaultValue (true)]
965 public bool MultiSelect {
966 get { return multiSelect; }
968 if (multiSelect != value) {
970 OnMultiSelectChanged(EventArgs.Empty);
976 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
977 public int NewRowIndex {
979 if (!AllowUserToAddRows || ColumnCount == 0) {
982 return rows.Count - 1;
987 [EditorBrowsable (EditorBrowsableState.Never)]
988 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
989 public new Padding Padding {
990 get { return Padding.Empty; }
994 internal DataGridViewHeaderCell PressedHeaderCell {
995 get { return pressed_header_cell; }
999 [DefaultValue (false)]
1000 public bool ReadOnly {
1001 get { return readOnly; }
1003 if (readOnly != value) {
1005 OnReadOnlyChanged(EventArgs.Empty);
1011 [EditorBrowsable (EditorBrowsableState.Advanced)]
1012 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
1014 public int RowCount {
1015 get { return rows.Count; }
1018 throw new ArgumentException("RowCount must be >= 0.");
1020 if (value < 1 && AllowUserToAddRows) {
1021 throw new ArgumentException("RowCount must be >= 1 if AllowUserToAddRows is true.");
1023 if (dataSource != null) {
1024 throw new InvalidOperationException("Cant change row count if DataSource is set.");
1027 if (value < rows.Count) {
1028 int removeRangeEndIndex = rows.Count - 1;
1029 if (AllowUserToAddRows)
1030 removeRangeEndIndex--; // do not remove editing row
1032 int removeRangeStartIndex = value - 1;
1033 if (AllowUserToAddRows)
1034 removeRangeStartIndex--; // remove an extra row before/instead of the editing row
1036 for (int i = removeRangeEndIndex; i > removeRangeStartIndex; i--)
1038 } else if (value > rows.Count) {
1039 // If we need to add rows and don't have any columns,
1040 // we create one column
1041 if (ColumnCount == 0)
1044 List<DataGridViewRow> newRows = new List<DataGridViewRow> (value - rows.Count);
1045 for (int i = rows.Count; i < value; i++)
1046 newRows.Add ((DataGridViewRow) RowTemplateFull);
1047 rows.AddRange (newRows.ToArray());
1053 [DefaultValue (DataGridViewHeaderBorderStyle.Raised)]
1054 public DataGridViewHeaderBorderStyle RowHeadersBorderStyle {
1055 get { return rowHeadersBorderStyle; }
1057 if (rowHeadersBorderStyle != value) {
1058 rowHeadersBorderStyle = value;
1059 OnRowHeadersBorderStyleChanged(EventArgs.Empty);
1064 [AmbientValue (null)]
1065 public DataGridViewCellStyle RowHeadersDefaultCellStyle {
1066 get { return rowHeadersDefaultCellStyle; }
1068 if (rowHeadersDefaultCellStyle != value) {
1069 rowHeadersDefaultCellStyle = value;
1070 OnRowHeadersDefaultCellStyleChanged(EventArgs.Empty);
1075 [DefaultValue (true)]
1076 public bool RowHeadersVisible {
1077 get { return rowHeadersVisible; }
1079 if (rowHeadersVisible != value) {
1080 rowHeadersVisible = value;
1086 [Localizable (true)]
1087 public int RowHeadersWidth {
1088 get { return rowHeadersWidth; }
1090 if (rowHeadersWidth != value) {
1092 throw new ArgumentOutOfRangeException("RowHeadersWidth",
1093 "Row headers width cant be less than 4.");
1095 if (value > 32768 ) {
1096 throw new ArgumentOutOfRangeException("RowHeadersWidth",
1097 "Row headers width cannot be more than 32768.");
1099 rowHeadersWidth = value;
1100 OnRowHeadersWidthChanged(EventArgs.Empty);
1102 if (rowHeadersVisible)
1108 [RefreshProperties (RefreshProperties.All)]
1109 [DefaultValue (DataGridViewRowHeadersWidthSizeMode.EnableResizing)]
1110 public DataGridViewRowHeadersWidthSizeMode RowHeadersWidthSizeMode {
1111 get { return rowHeadersWidthSizeMode; }
1113 if (rowHeadersWidthSizeMode != value) {
1114 if (!Enum.IsDefined(typeof(DataGridViewRowHeadersWidthSizeMode), value)) {
1115 throw new InvalidEnumArgumentException("Value is not valid DataGridViewRowHeadersWidthSizeMode.");
1117 rowHeadersWidthSizeMode = value;
1118 OnRowHeadersWidthSizeModeChanged(new DataGridViewAutoSizeModeEventArgs(false));
1124 public DataGridViewRowCollection Rows {
1125 get { return rows; }
1128 public DataGridViewCellStyle RowsDefaultCellStyle {
1129 get { return rowsDefaultCellStyle; }
1131 if (rowsDefaultCellStyle != value) {
1132 rowsDefaultCellStyle = value;
1133 OnRowsDefaultCellStyleChanged(EventArgs.Empty);
1138 // RowTemplate is just the row, it does not contain Cells
1140 [DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]
1141 public DataGridViewRow RowTemplate {
1143 if (rowTemplate == null)
1144 rowTemplate = new DataGridViewRow ();
1149 rowTemplate = value;
1153 // Take the RowTemplate, clone it, and add Cells
1154 // Note this is not stored, so you don't need to Clone it
1155 internal DataGridViewRow RowTemplateFull {
1157 DataGridViewRow row = (DataGridViewRow) RowTemplate.Clone ();
1159 for (int i = row.Cells.Count; i < Columns.Count; i++) {
1160 DataGridViewCell template = columns [i].CellTemplate;
1162 if (template == null)
1163 throw new InvalidOperationException ("At least one of the DataGridView control's columns has no cell template.");
1165 row.Cells.Add ((DataGridViewCell) template.Clone ());
1172 internal override bool ScaleChildrenInternal {
1173 get { return false; }
1176 [DefaultValue (ScrollBars.Both)]
1177 [Localizable (true)]
1178 public ScrollBars ScrollBars {
1179 get { return scrollBars; }
1181 if (!Enum.IsDefined(typeof(ScrollBars), value)) {
1182 throw new InvalidEnumArgumentException("Invalid ScrollBars value.");
1184 ////////////////////////////////////////////////////////////
1185 /// *** InvalidOperationException ***
1186 /// The System.Windows.Forms.DataGridView is unable to
1187 /// scroll due to a cell change that cannot be committed
1189 ///////////////////////////////////////////////////////////
1197 public DataGridViewSelectedCellCollection SelectedCells {
1199 DataGridViewSelectedCellCollection selectedCells = new DataGridViewSelectedCellCollection();
1200 foreach (DataGridViewRow row in rows) {
1201 foreach (DataGridViewCell cell in row.Cells) {
1202 if (cell.Selected) {
1203 selectedCells.InternalAdd(cell);
1207 return selectedCells;
1212 public DataGridViewSelectedColumnCollection SelectedColumns {
1215 DataGridViewSelectedColumnCollection result = new DataGridViewSelectedColumnCollection ();
1217 if (selectionMode != DataGridViewSelectionMode.FullColumnSelect && selectionMode != DataGridViewSelectionMode.ColumnHeaderSelect)
1220 result.InternalAddRange (selected_columns);
1227 public DataGridViewSelectedRowCollection SelectedRows {
1229 DataGridViewSelectedRowCollection result = new DataGridViewSelectedRowCollection (this);
1231 if (selectionMode != DataGridViewSelectionMode.FullRowSelect && selectionMode != DataGridViewSelectionMode.RowHeaderSelect)
1234 result.InternalAddRange (selected_rows);
1241 [DefaultValue (DataGridViewSelectionMode.RowHeaderSelect)]
1242 public DataGridViewSelectionMode SelectionMode {
1243 get { return selectionMode; }
1245 if (!Enum.IsDefined (typeof(DataGridViewSelectionMode), value))
1246 throw new InvalidEnumArgumentException ("Value is not valid DataGridViewSelectionMode.");
1248 if (value == DataGridViewSelectionMode.ColumnHeaderSelect || value == DataGridViewSelectionMode.FullColumnSelect)
1249 foreach (DataGridViewColumn col in Columns)
1250 if (col.SortMode == DataGridViewColumnSortMode.Automatic)
1251 throw new InvalidOperationException (string.Format ("Cannot set SelectionMode to {0} because there are Automatic sort columns.", value));
1253 selectionMode = value;
1257 [DefaultValue (true)]
1258 public bool ShowCellErrors {
1259 get { return showCellErrors; }
1260 set { showCellErrors = value; }
1263 [DefaultValue (true)]
1264 public bool ShowCellToolTips {
1265 get { return showCellToolTips; }
1266 set { showCellToolTips = value; }
1269 [DefaultValue (true)]
1270 public bool ShowEditingIcon {
1271 get { return showEditingIcon; }
1272 set { showEditingIcon = value; }
1275 [DefaultValue (true)]
1276 public bool ShowRowErrors {
1277 get { return showRowErrors; }
1278 set { showRowErrors = value; }
1282 public DataGridViewColumn SortedColumn {
1283 get { return sortedColumn; }
1287 public SortOrder SortOrder {
1288 get { return sortOrder; }
1291 [DefaultValue (false)]
1292 [EditorBrowsable (EditorBrowsableState.Advanced)]
1293 public bool StandardTab {
1294 get { return standardTab; }
1295 set { standardTab = value; }
1300 [EditorBrowsable (EditorBrowsableState.Never)]
1301 public override string Text {
1302 get { return base.Text; }
1303 set { base.Text = value; }
1307 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
1308 public DataGridViewHeaderCell TopLeftHeaderCell {
1310 if (topLeftHeaderCell == null) {
1311 topLeftHeaderCell = new DataGridViewTopLeftHeaderCell ();
1312 topLeftHeaderCell.SetDataGridView (this);
1314 return topLeftHeaderCell;
1317 if (topLeftHeaderCell == value)
1320 if (topLeftHeaderCell != null)
1321 topLeftHeaderCell.SetDataGridView (null);
1323 topLeftHeaderCell = value;
1325 if (topLeftHeaderCell != null)
1326 topLeftHeaderCell.SetDataGridView (this);
1331 [EditorBrowsable (EditorBrowsableState.Advanced)]
1332 public Cursor UserSetCursor {
1333 get { return userSetCursor; }
1337 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
1338 public int VerticalScrollingOffset {
1339 get { return verticalScrollingOffset; }
1342 [MonoTODO ("VirtualMode is not supported.")]
1343 [EditorBrowsable (EditorBrowsableState.Advanced)]
1344 [DefaultValue (false)]
1345 public bool VirtualMode {
1346 get { return virtualMode; }
1347 set { virtualMode = value; }
1350 internal Control EditingControlInternal {
1352 return editingControl;
1355 if (value == editingControl)
1358 if (editingControl != null) {
1359 // Can't use Controls.Remove (editingControls), because that method
1360 // is overriden to not remove the editing control.
1361 DataGridView.DataGridViewControlCollection ctrls = Controls as DataGridView.DataGridViewControlCollection;
1362 if (ctrls != null) {
1363 ctrls.RemoveInternal (editingControl);
1365 Controls.Remove (editingControl);
1370 if (value != null) {
1371 value.Visible = false;
1372 Controls.Add (value);
1375 editingControl = value;
1379 static object AllowUserToAddRowsChangedEvent = new object ();
1380 static object AllowUserToDeleteRowsChangedEvent = new object ();
1381 static object AllowUserToOrderColumnsChangedEvent = new object ();
1382 static object AllowUserToResizeColumnsChangedEvent = new object ();
1383 static object AllowUserToResizeRowsChangedEvent = new object ();
1384 static object AlternatingRowsDefaultCellStyleChangedEvent = new object ();
1385 static object AutoGenerateColumnsChangedEvent = new object ();
1386 static object AutoSizeColumnModeChangedEvent = new object ();
1387 static object AutoSizeColumnsModeChangedEvent = new object ();
1388 static object AutoSizeRowsModeChangedEvent = new object ();
1389 static object BackgroundColorChangedEvent = new object ();
1390 static object BorderStyleChangedEvent = new object ();
1391 static object CancelRowEditEvent = new object ();
1392 static object CellBeginEditEvent = new object ();
1393 static object CellBorderStyleChangedEvent = new object ();
1394 static object CellClickEvent = new object ();
1395 static object CellContentClickEvent = new object ();
1396 static object CellContentDoubleClickEvent = new object ();
1397 static object CellContextMenuStripChangedEvent = new object ();
1398 static object CellContextMenuStripNeededEvent = new object ();
1399 static object CellDoubleClickEvent = new object ();
1400 static object CellEndEditEvent = new object ();
1401 static object CellEnterEvent = new object ();
1402 static object CellErrorTextChangedEvent = new object ();
1403 static object CellErrorTextNeededEvent = new object ();
1404 static object CellFormattingEvent = new object ();
1405 static object CellLeaveEvent = new object ();
1406 static object CellMouseClickEvent = new object ();
1407 static object CellMouseDoubleClickEvent = new object ();
1408 static object CellMouseDownEvent = new object ();
1409 static object CellMouseEnterEvent = new object ();
1410 static object CellMouseLeaveEvent = new object ();
1411 static object CellMouseMoveEvent = new object ();
1412 static object CellMouseUpEvent = new object ();
1413 static object CellPaintingEvent = new object ();
1414 static object CellParsingEvent = new object ();
1415 static object CellStateChangedEvent = new object ();
1416 static object CellStyleChangedEvent = new object ();
1417 static object CellStyleContentChangedEvent = new object ();
1418 static object CellToolTipTextChangedEvent = new object ();
1419 static object CellToolTipTextNeededEvent = new object ();
1420 static object CellValidatedEvent = new object ();
1421 static object CellValidatingEvent = new object ();
1422 static object CellValueChangedEvent = new object ();
1423 static object CellValueNeededEvent = new object ();
1424 static object CellValuePushedEvent = new object ();
1425 static object ColumnAddedEvent = new object ();
1426 static object ColumnContextMenuStripChangedEvent = new object ();
1427 static object ColumnDataPropertyNameChangedEvent = new object ();
1428 static object ColumnDefaultCellStyleChangedEvent = new object ();
1429 static object ColumnDisplayIndexChangedEvent = new object ();
1430 static object ColumnDividerDoubleClickEvent = new object ();
1431 static object ColumnDividerWidthChangedEvent = new object ();
1432 static object ColumnHeaderCellChangedEvent = new object ();
1433 static object ColumnHeaderMouseClickEvent = new object ();
1434 static object ColumnHeaderMouseDoubleClickEvent = new object ();
1435 static object ColumnHeadersBorderStyleChangedEvent = new object ();
1436 static object ColumnHeadersDefaultCellStyleChangedEvent = new object ();
1437 static object ColumnHeadersHeightChangedEvent = new object ();
1438 static object ColumnHeadersHeightSizeModeChangedEvent = new object ();
1439 static object ColumnMinimumWidthChangedEvent = new object ();
1440 static object ColumnNameChangedEvent = new object ();
1441 static object ColumnRemovedEvent = new object ();
1442 static object ColumnSortModeChangedEvent = new object ();
1443 static object ColumnStateChangedEvent = new object ();
1444 static object ColumnToolTipTextChangedEvent = new object ();
1445 static object ColumnWidthChangedEvent = new object ();
1446 static object CurrentCellChangedEvent = new object ();
1447 static object CurrentCellDirtyStateChangedEvent = new object ();
1448 static object DataBindingCompleteEvent = new object ();
1449 static object DataErrorEvent = new object ();
1450 static object DataMemberChangedEvent = new object ();
1451 static object DataSourceChangedEvent = new object ();
1452 static object DefaultCellStyleChangedEvent = new object ();
1453 static object DefaultValuesNeededEvent = new object ();
1454 static object EditingControlShowingEvent = new object ();
1455 static object EditModeChangedEvent = new object ();
1456 static object GridColorChangedEvent = new object ();
1457 static object MultiSelectChangedEvent = new object ();
1458 static object NewRowNeededEvent = new object ();
1459 static object ReadOnlyChangedEvent = new object ();
1460 static object RowContextMenuStripChangedEvent = new object ();
1461 static object RowContextMenuStripNeededEvent = new object ();
1462 static object RowDefaultCellStyleChangedEvent = new object ();
1463 static object RowDirtyStateNeededEvent = new object ();
1464 static object RowDividerDoubleClickEvent = new object ();
1465 static object RowDividerHeightChangedEvent = new object ();
1466 static object RowEnterEvent = new object ();
1467 static object RowErrorTextChangedEvent = new object ();
1468 static object RowErrorTextNeededEvent = new object ();
1469 static object RowHeaderCellChangedEvent = new object ();
1470 static object RowHeaderMouseClickEvent = new object ();
1471 static object RowHeaderMouseDoubleClickEvent = new object ();
1472 static object RowHeadersBorderStyleChangedEvent = new object ();
1473 static object RowHeadersDefaultCellStyleChangedEvent = new object ();
1474 static object RowHeadersWidthChangedEvent = new object ();
1475 static object RowHeadersWidthSizeModeChangedEvent = new object ();
1476 static object RowHeightChangedEvent = new object ();
1477 static object RowHeightInfoNeededEvent = new object ();
1478 static object RowHeightInfoPushedEvent = new object ();
1479 static object RowLeaveEvent = new object ();
1480 static object RowMinimumHeightChangedEvent = new object ();
1481 static object RowPostPaintEvent = new object ();
1482 static object RowPrePaintEvent = new object ();
1483 static object RowsAddedEvent = new object ();
1484 static object RowsDefaultCellStyleChangedEvent = new object ();
1485 static object RowsRemovedEvent = new object ();
1486 static object RowStateChangedEvent = new object ();
1487 static object RowUnsharedEvent = new object ();
1488 static object RowValidatedEvent = new object ();
1489 static object RowValidatingEvent = new object ();
1490 static object ScrollEvent = new object ();
1491 static object SelectionChangedEvent = new object ();
1492 static object SortCompareEvent = new object ();
1493 static object SortedEvent = new object ();
1494 static object UserAddedRowEvent = new object ();
1495 static object UserDeletedRowEvent = new object ();
1496 static object UserDeletingRowEvent = new object ();
1501 public event EventHandler AllowUserToAddRowsChanged {
1502 add { Events.AddHandler (AllowUserToAddRowsChangedEvent, value); }
1503 remove { Events.RemoveHandler (AllowUserToAddRowsChangedEvent, value); }
1506 public event EventHandler AllowUserToDeleteRowsChanged {
1507 add { Events.AddHandler (AllowUserToDeleteRowsChangedEvent, value); }
1508 remove { Events.RemoveHandler (AllowUserToDeleteRowsChangedEvent, value); }
1511 public event EventHandler AllowUserToOrderColumnsChanged {
1512 add { Events.AddHandler (AllowUserToOrderColumnsChangedEvent, value); }
1513 remove { Events.RemoveHandler (AllowUserToOrderColumnsChangedEvent, value); }
1516 public event EventHandler AllowUserToResizeColumnsChanged {
1517 add { Events.AddHandler (AllowUserToResizeColumnsChangedEvent, value); }
1518 remove { Events.RemoveHandler (AllowUserToResizeColumnsChangedEvent, value); }
1521 public event EventHandler AllowUserToResizeRowsChanged {
1522 add { Events.AddHandler (AllowUserToResizeRowsChangedEvent, value); }
1523 remove { Events.RemoveHandler (AllowUserToResizeRowsChangedEvent, value); }
1526 public event EventHandler AlternatingRowsDefaultCellStyleChanged {
1527 add { Events.AddHandler (AlternatingRowsDefaultCellStyleChangedEvent, value); }
1528 remove { Events.RemoveHandler (AlternatingRowsDefaultCellStyleChangedEvent, value); }
1532 [EditorBrowsable (EditorBrowsableState.Advanced)]
1533 public event EventHandler AutoGenerateColumnsChanged {
1534 add { Events.AddHandler (AutoGenerateColumnsChangedEvent, value); }
1535 remove { Events.RemoveHandler (AutoGenerateColumnsChangedEvent, value); }
1538 public event DataGridViewAutoSizeColumnModeEventHandler AutoSizeColumnModeChanged {
1539 add { Events.AddHandler (AutoSizeColumnModeChangedEvent, value); }
1540 remove { Events.RemoveHandler (AutoSizeColumnModeChangedEvent, value); }
1543 public event DataGridViewAutoSizeColumnsModeEventHandler AutoSizeColumnsModeChanged {
1544 add { Events.AddHandler (AutoSizeColumnsModeChangedEvent, value); }
1545 remove { Events.RemoveHandler (AutoSizeColumnsModeChangedEvent, value); }
1548 public event DataGridViewAutoSizeModeEventHandler AutoSizeRowsModeChanged {
1549 add { Events.AddHandler (AutoSizeRowsModeChangedEvent, value); }
1550 remove { Events.RemoveHandler (AutoSizeRowsModeChangedEvent, value); }
1554 [EditorBrowsable (EditorBrowsableState.Never)]
1555 public new event EventHandler BackColorChanged {
1556 add { base.BackColorChanged += value; }
1557 remove { base.BackColorChanged -= value; }
1560 public event EventHandler BackgroundColorChanged {
1561 add { Events.AddHandler (BackgroundColorChangedEvent, value); }
1562 remove { Events.RemoveHandler (BackgroundColorChangedEvent, value); }
1566 [EditorBrowsable (EditorBrowsableState.Never)]
1567 public new event EventHandler BackgroundImageChanged {
1568 add { base.BackgroundImageChanged += value; }
1569 remove { base.BackgroundImageChanged -= value; }
1573 [EditorBrowsable (EditorBrowsableState.Never)]
1574 public new event EventHandler BackgroundImageLayoutChanged {
1575 add { base.BackgroundImageLayoutChanged += value; }
1576 remove { base.BackgroundImageLayoutChanged -= value; }
1579 public event EventHandler BorderStyleChanged {
1580 add { Events.AddHandler (BorderStyleChangedEvent, value); }
1581 remove { Events.RemoveHandler (BorderStyleChangedEvent, value); }
1584 public event QuestionEventHandler CancelRowEdit {
1585 add { Events.AddHandler (CancelRowEditEvent, value); }
1586 remove { Events.RemoveHandler (CancelRowEditEvent, value); }
1589 public event DataGridViewCellCancelEventHandler CellBeginEdit {
1590 add { Events.AddHandler (CellBeginEditEvent, value); }
1591 remove { Events.RemoveHandler (CellBeginEditEvent, value); }
1594 public event EventHandler CellBorderStyleChanged {
1595 add { Events.AddHandler (CellBorderStyleChangedEvent, value); }
1596 remove { Events.RemoveHandler (CellBorderStyleChangedEvent, value); }
1599 public event DataGridViewCellEventHandler CellClick {
1600 add { Events.AddHandler (CellClickEvent, value); }
1601 remove { Events.RemoveHandler (CellClickEvent, value); }
1604 public event DataGridViewCellEventHandler CellContentClick {
1605 add { Events.AddHandler (CellContentClickEvent, value); }
1606 remove { Events.RemoveHandler (CellContentClickEvent, value); }
1609 public event DataGridViewCellEventHandler CellContentDoubleClick {
1610 add { Events.AddHandler (CellContentDoubleClickEvent, value); }
1611 remove { Events.RemoveHandler (CellContentDoubleClickEvent, value); }
1614 [EditorBrowsable (EditorBrowsableState.Advanced)]
1615 public event DataGridViewCellEventHandler CellContextMenuStripChanged {
1616 add { Events.AddHandler (CellContextMenuStripChangedEvent, value); }
1617 remove { Events.RemoveHandler (CellContextMenuStripChangedEvent, value); }
1620 [EditorBrowsable (EditorBrowsableState.Advanced)]
1621 public event DataGridViewCellContextMenuStripNeededEventHandler CellContextMenuStripNeeded {
1622 add { Events.AddHandler (CellContextMenuStripNeededEvent, value); }
1623 remove { Events.RemoveHandler (CellContextMenuStripNeededEvent, value); }
1626 public event DataGridViewCellEventHandler CellDoubleClick {
1627 add { Events.AddHandler (CellDoubleClickEvent, value); }
1628 remove { Events.RemoveHandler (CellDoubleClickEvent, value); }
1631 public event DataGridViewCellEventHandler CellEndEdit {
1632 add { Events.AddHandler (CellEndEditEvent, value); }
1633 remove { Events.RemoveHandler (CellEndEditEvent, value); }
1636 public event DataGridViewCellEventHandler CellEnter {
1637 add { Events.AddHandler (CellEnterEvent, value); }
1638 remove { Events.RemoveHandler (CellEnterEvent, value); }
1641 public event DataGridViewCellEventHandler CellErrorTextChanged {
1642 add { Events.AddHandler (CellErrorTextChangedEvent, value); }
1643 remove { Events.RemoveHandler (CellErrorTextChangedEvent, value); }
1646 [EditorBrowsable (EditorBrowsableState.Advanced)]
1647 public event DataGridViewCellErrorTextNeededEventHandler CellErrorTextNeeded {
1648 add { Events.AddHandler (CellErrorTextNeededEvent, value); }
1649 remove { Events.RemoveHandler (CellErrorTextNeededEvent, value); }
1652 public event DataGridViewCellFormattingEventHandler CellFormatting {
1653 add { Events.AddHandler (CellFormattingEvent, value); }
1654 remove { Events.RemoveHandler (CellFormattingEvent, value); }
1657 public event DataGridViewCellEventHandler CellLeave {
1658 add { Events.AddHandler (CellLeaveEvent, value); }
1659 remove { Events.RemoveHandler (CellLeaveEvent, value); }
1662 public event DataGridViewCellMouseEventHandler CellMouseClick {
1663 add { Events.AddHandler (CellMouseClickEvent, value); }
1664 remove { Events.RemoveHandler (CellMouseClickEvent, value); }
1667 public event DataGridViewCellMouseEventHandler CellMouseDoubleClick {
1668 add { Events.AddHandler (CellMouseDoubleClickEvent, value); }
1669 remove { Events.RemoveHandler (CellMouseDoubleClickEvent, value); }
1672 public event DataGridViewCellMouseEventHandler CellMouseDown {
1673 add { Events.AddHandler (CellMouseDownEvent, value); }
1674 remove { Events.RemoveHandler (CellMouseDownEvent, value); }
1677 public event DataGridViewCellEventHandler CellMouseEnter {
1678 add { Events.AddHandler (CellMouseEnterEvent, value); }
1679 remove { Events.RemoveHandler (CellMouseEnterEvent, value); }
1682 public event DataGridViewCellEventHandler CellMouseLeave {
1683 add { Events.AddHandler (CellMouseLeaveEvent, value); }
1684 remove { Events.RemoveHandler (CellMouseLeaveEvent, value); }
1687 public event DataGridViewCellMouseEventHandler CellMouseMove {
1688 add { Events.AddHandler (CellMouseMoveEvent, value); }
1689 remove { Events.RemoveHandler (CellMouseMoveEvent, value); }
1692 public event DataGridViewCellMouseEventHandler CellMouseUp {
1693 add { Events.AddHandler (CellMouseUpEvent, value); }
1694 remove { Events.RemoveHandler (CellMouseUpEvent, value); }
1697 public event DataGridViewCellPaintingEventHandler CellPainting {
1698 add { Events.AddHandler (CellPaintingEvent, value); }
1699 remove { Events.RemoveHandler (CellPaintingEvent, value); }
1702 public event DataGridViewCellParsingEventHandler CellParsing {
1703 add { Events.AddHandler (CellParsingEvent, value); }
1704 remove { Events.RemoveHandler (CellParsingEvent, value); }
1707 public event DataGridViewCellStateChangedEventHandler CellStateChanged {
1708 add { Events.AddHandler (CellStateChangedEvent, value); }
1709 remove { Events.RemoveHandler (CellStateChangedEvent, value); }
1712 public event DataGridViewCellEventHandler CellStyleChanged {
1713 add { Events.AddHandler (CellStyleChangedEvent, value); }
1714 remove { Events.RemoveHandler (CellStyleChangedEvent, value); }
1717 public event DataGridViewCellStyleContentChangedEventHandler CellStyleContentChanged {
1718 add { Events.AddHandler (CellStyleContentChangedEvent, value); }
1719 remove { Events.RemoveHandler (CellStyleContentChangedEvent, value); }
1722 public event DataGridViewCellEventHandler CellToolTipTextChanged {
1723 add { Events.AddHandler (CellToolTipTextChangedEvent, value); }
1724 remove { Events.RemoveHandler (CellToolTipTextChangedEvent, value); }
1727 [EditorBrowsable (EditorBrowsableState.Advanced)]
1728 public event DataGridViewCellToolTipTextNeededEventHandler CellToolTipTextNeeded {
1729 add { Events.AddHandler (CellToolTipTextNeededEvent, value); }
1730 remove { Events.RemoveHandler (CellToolTipTextNeededEvent, value); }
1733 public event DataGridViewCellEventHandler CellValidated {
1734 add { Events.AddHandler (CellValidatedEvent, value); }
1735 remove { Events.RemoveHandler (CellValidatedEvent, value); }
1738 public event DataGridViewCellValidatingEventHandler CellValidating {
1739 add { Events.AddHandler (CellValidatingEvent, value); }
1740 remove { Events.RemoveHandler (CellValidatingEvent, value); }
1743 public event DataGridViewCellEventHandler CellValueChanged {
1744 add { Events.AddHandler (CellValueChangedEvent, value); }
1745 remove { Events.RemoveHandler (CellValueChangedEvent, value); }
1748 [EditorBrowsable (EditorBrowsableState.Advanced)]
1749 public event DataGridViewCellValueEventHandler CellValueNeeded {
1750 add { Events.AddHandler (CellValueNeededEvent, value); }
1751 remove { Events.RemoveHandler (CellValueNeededEvent, value); }
1754 [EditorBrowsable (EditorBrowsableState.Advanced)]
1755 public event DataGridViewCellValueEventHandler CellValuePushed {
1756 add { Events.AddHandler (CellValuePushedEvent, value); }
1757 remove { Events.RemoveHandler (CellValuePushedEvent, value); }
1760 public event DataGridViewColumnEventHandler ColumnAdded {
1761 add { Events.AddHandler (ColumnAddedEvent, value); }
1762 remove { Events.RemoveHandler (ColumnAddedEvent, value); }
1765 public event DataGridViewColumnEventHandler ColumnContextMenuStripChanged {
1766 add { Events.AddHandler (ColumnContextMenuStripChangedEvent, value); }
1767 remove { Events.RemoveHandler (ColumnContextMenuStripChangedEvent, value); }
1770 public event DataGridViewColumnEventHandler ColumnDataPropertyNameChanged {
1771 add { Events.AddHandler (ColumnDataPropertyNameChangedEvent, value); }
1772 remove { Events.RemoveHandler (ColumnDataPropertyNameChangedEvent, value); }
1775 public event DataGridViewColumnEventHandler ColumnDefaultCellStyleChanged {
1776 add { Events.AddHandler (ColumnDefaultCellStyleChangedEvent, value); }
1777 remove { Events.RemoveHandler (ColumnDefaultCellStyleChangedEvent, value); }
1780 public event DataGridViewColumnEventHandler ColumnDisplayIndexChanged {
1781 add { Events.AddHandler (ColumnDisplayIndexChangedEvent, value); }
1782 remove { Events.RemoveHandler (ColumnDisplayIndexChangedEvent, value); }
1785 public event DataGridViewColumnDividerDoubleClickEventHandler ColumnDividerDoubleClick {
1786 add { Events.AddHandler (ColumnDividerDoubleClickEvent, value); }
1787 remove { Events.RemoveHandler (ColumnDividerDoubleClickEvent, value); }
1790 public event DataGridViewColumnEventHandler ColumnDividerWidthChanged {
1791 add { Events.AddHandler (ColumnDividerWidthChangedEvent, value); }
1792 remove { Events.RemoveHandler (ColumnDividerWidthChangedEvent, value); }
1795 public event DataGridViewColumnEventHandler ColumnHeaderCellChanged {
1796 add { Events.AddHandler (ColumnHeaderCellChangedEvent, value); }
1797 remove { Events.RemoveHandler (ColumnHeaderCellChangedEvent, value); }
1800 public event DataGridViewCellMouseEventHandler ColumnHeaderMouseClick {
1801 add { Events.AddHandler (ColumnHeaderMouseClickEvent, value); }
1802 remove { Events.RemoveHandler (ColumnHeaderMouseClickEvent, value); }
1805 public event DataGridViewCellMouseEventHandler ColumnHeaderMouseDoubleClick {
1806 add { Events.AddHandler (ColumnHeaderMouseDoubleClickEvent, value); }
1807 remove { Events.RemoveHandler (ColumnHeaderMouseDoubleClickEvent, value); }
1810 public event EventHandler ColumnHeadersBorderStyleChanged {
1811 add { Events.AddHandler (ColumnHeadersBorderStyleChangedEvent, value); }
1812 remove { Events.RemoveHandler (ColumnHeadersBorderStyleChangedEvent, value); }
1815 public event EventHandler ColumnHeadersDefaultCellStyleChanged {
1816 add { Events.AddHandler (ColumnHeadersDefaultCellStyleChangedEvent, value); }
1817 remove { Events.RemoveHandler (ColumnHeadersDefaultCellStyleChangedEvent, value); }
1820 public event EventHandler ColumnHeadersHeightChanged {
1821 add { Events.AddHandler (ColumnHeadersHeightChangedEvent, value); }
1822 remove { Events.RemoveHandler (ColumnHeadersHeightChangedEvent, value); }
1825 public event DataGridViewAutoSizeModeEventHandler ColumnHeadersHeightSizeModeChanged {
1826 add { Events.AddHandler (ColumnHeadersHeightSizeModeChangedEvent, value); }
1827 remove { Events.RemoveHandler (ColumnHeadersHeightSizeModeChangedEvent, value); }
1830 public event DataGridViewColumnEventHandler ColumnMinimumWidthChanged {
1831 add { Events.AddHandler (ColumnMinimumWidthChangedEvent, value); }
1832 remove { Events.RemoveHandler (ColumnMinimumWidthChangedEvent, value); }
1835 public event DataGridViewColumnEventHandler ColumnNameChanged {
1836 add { Events.AddHandler (ColumnNameChangedEvent, value); }
1837 remove { Events.RemoveHandler (ColumnNameChangedEvent, value); }
1840 public event DataGridViewColumnEventHandler ColumnRemoved {
1841 add { Events.AddHandler (ColumnRemovedEvent, value); }
1842 remove { Events.RemoveHandler (ColumnRemovedEvent, value); }
1845 public event DataGridViewColumnEventHandler ColumnSortModeChanged {
1846 add { Events.AddHandler (ColumnSortModeChangedEvent, value); }
1847 remove { Events.RemoveHandler (ColumnSortModeChangedEvent, value); }
1850 public event DataGridViewColumnStateChangedEventHandler ColumnStateChanged {
1851 add { Events.AddHandler (ColumnStateChangedEvent, value); }
1852 remove { Events.RemoveHandler (ColumnStateChangedEvent, value); }
1855 public event DataGridViewColumnEventHandler ColumnToolTipTextChanged {
1856 add { Events.AddHandler (ColumnToolTipTextChangedEvent, value); }
1857 remove { Events.RemoveHandler (ColumnToolTipTextChangedEvent, value); }
1860 public event DataGridViewColumnEventHandler ColumnWidthChanged {
1861 add { Events.AddHandler (ColumnWidthChangedEvent, value); }
1862 remove { Events.RemoveHandler (ColumnWidthChangedEvent, value); }
1865 public event EventHandler CurrentCellChanged {
1866 add { Events.AddHandler (CurrentCellChangedEvent, value); }
1867 remove { Events.RemoveHandler (CurrentCellChangedEvent, value); }
1870 [EditorBrowsable (EditorBrowsableState.Advanced)]
1871 public event EventHandler CurrentCellDirtyStateChanged {
1872 add { Events.AddHandler (CurrentCellDirtyStateChangedEvent, value); }
1873 remove { Events.RemoveHandler (CurrentCellDirtyStateChangedEvent, value); }
1876 public event DataGridViewBindingCompleteEventHandler DataBindingComplete {
1877 add { Events.AddHandler (DataBindingCompleteEvent, value); }
1878 remove { Events.RemoveHandler (DataBindingCompleteEvent, value); }
1881 public event DataGridViewDataErrorEventHandler DataError {
1882 add { Events.AddHandler (DataErrorEvent, value); }
1883 remove { Events.RemoveHandler (DataErrorEvent, value); }
1886 public event EventHandler DataMemberChanged {
1887 add { Events.AddHandler (DataMemberChangedEvent, value); }
1888 remove { Events.RemoveHandler (DataMemberChangedEvent, value); }
1891 public event EventHandler DataSourceChanged {
1892 add { Events.AddHandler (DataSourceChangedEvent, value); }
1893 remove { Events.RemoveHandler (DataSourceChangedEvent, value); }
1896 public event EventHandler DefaultCellStyleChanged {
1897 add { Events.AddHandler (DefaultCellStyleChangedEvent, value); }
1898 remove { Events.RemoveHandler (DefaultCellStyleChangedEvent, value); }
1901 [EditorBrowsable (EditorBrowsableState.Advanced)]
1902 public event DataGridViewRowEventHandler DefaultValuesNeeded {
1903 add { Events.AddHandler (DefaultValuesNeededEvent, value); }
1904 remove { Events.RemoveHandler (DefaultValuesNeededEvent, value); }
1907 public event DataGridViewEditingControlShowingEventHandler EditingControlShowing {
1908 add { Events.AddHandler (EditingControlShowingEvent, value); }
1909 remove { Events.RemoveHandler (EditingControlShowingEvent, value); }
1912 public event EventHandler EditModeChanged {
1913 add { Events.AddHandler (EditModeChangedEvent, value); }
1914 remove { Events.RemoveHandler (EditModeChangedEvent, value); }
1918 [EditorBrowsable (EditorBrowsableState.Advanced)]
1919 public new event EventHandler FontChanged {
1920 add { base.FontChanged += value; }
1921 remove { base.FontChanged -= value; }
1925 [EditorBrowsable (EditorBrowsableState.Advanced)]
1926 public new event EventHandler ForeColorChanged {
1927 add { base.ForeColorChanged += value; }
1928 remove { base.ForeColorChanged -= value; }
1932 [EditorBrowsable (EditorBrowsableState.Never)]
1933 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
1934 public new event EventHandler PaddingChanged {
1935 add { base.PaddingChanged += value; }
1936 remove { base.PaddingChanged -= value; }
1939 public event EventHandler GridColorChanged {
1940 add { Events.AddHandler (GridColorChangedEvent, value); }
1941 remove { Events.RemoveHandler (GridColorChangedEvent, value); }
1944 public event EventHandler MultiSelectChanged {
1945 add { Events.AddHandler (MultiSelectChangedEvent, value); }
1946 remove { Events.RemoveHandler (MultiSelectChangedEvent, value); }
1949 public event DataGridViewRowEventHandler NewRowNeeded {
1950 add { Events.AddHandler (NewRowNeededEvent, value); }
1951 remove { Events.RemoveHandler (NewRowNeededEvent, value); }
1954 public event EventHandler ReadOnlyChanged {
1955 add { Events.AddHandler (ReadOnlyChangedEvent, value); }
1956 remove { Events.RemoveHandler (ReadOnlyChangedEvent, value); }
1959 public event DataGridViewRowEventHandler RowContextMenuStripChanged {
1960 add { Events.AddHandler (RowContextMenuStripChangedEvent, value); }
1961 remove { Events.RemoveHandler (RowContextMenuStripChangedEvent, value); }
1964 [EditorBrowsable (EditorBrowsableState.Advanced)]
1965 public event DataGridViewRowContextMenuStripNeededEventHandler RowContextMenuStripNeeded {
1966 add { Events.AddHandler (RowContextMenuStripNeededEvent, value); }
1967 remove { Events.RemoveHandler (RowContextMenuStripNeededEvent, value); }
1970 public event DataGridViewRowEventHandler RowDefaultCellStyleChanged {
1971 add { Events.AddHandler (RowDefaultCellStyleChangedEvent, value); }
1972 remove { Events.RemoveHandler (RowDefaultCellStyleChangedEvent, value); }
1975 [EditorBrowsable (EditorBrowsableState.Advanced)]
1976 public event QuestionEventHandler RowDirtyStateNeeded {
1977 add { Events.AddHandler (RowDirtyStateNeededEvent, value); }
1978 remove { Events.RemoveHandler (RowDirtyStateNeededEvent, value); }
1981 public event DataGridViewRowDividerDoubleClickEventHandler RowDividerDoubleClick {
1982 add { Events.AddHandler (RowDividerDoubleClickEvent, value); }
1983 remove { Events.RemoveHandler (RowDividerDoubleClickEvent, value); }
1986 public event DataGridViewRowEventHandler RowDividerHeightChanged {
1987 add { Events.AddHandler (RowDividerHeightChangedEvent, value); }
1988 remove { Events.RemoveHandler (RowDividerHeightChangedEvent, value); }
1991 public event DataGridViewCellEventHandler RowEnter {
1992 add { Events.AddHandler (RowEnterEvent, value); }
1993 remove { Events.RemoveHandler (RowEnterEvent, value); }
1996 public event DataGridViewRowEventHandler RowErrorTextChanged {
1997 add { Events.AddHandler (RowErrorTextChangedEvent, value); }
1998 remove { Events.RemoveHandler (RowErrorTextChangedEvent, value); }
2001 [EditorBrowsable (EditorBrowsableState.Advanced)]
2002 public event DataGridViewRowErrorTextNeededEventHandler RowErrorTextNeeded {
2003 add { Events.AddHandler (RowErrorTextNeededEvent, value); }
2004 remove { Events.RemoveHandler (RowErrorTextNeededEvent, value); }
2007 public event DataGridViewRowEventHandler RowHeaderCellChanged {
2008 add { Events.AddHandler (RowHeaderCellChangedEvent, value); }
2009 remove { Events.RemoveHandler (RowHeaderCellChangedEvent, value); }
2012 public event DataGridViewCellMouseEventHandler RowHeaderMouseClick {
2013 add { Events.AddHandler (RowHeaderMouseClickEvent, value); }
2014 remove { Events.RemoveHandler (RowHeaderMouseClickEvent, value); }
2017 public event DataGridViewCellMouseEventHandler RowHeaderMouseDoubleClick {
2018 add { Events.AddHandler (RowHeaderMouseDoubleClickEvent, value); }
2019 remove { Events.RemoveHandler (RowHeaderMouseDoubleClickEvent, value); }
2022 public event EventHandler RowHeadersBorderStyleChanged {
2023 add { Events.AddHandler (RowHeadersBorderStyleChangedEvent, value); }
2024 remove { Events.RemoveHandler (RowHeadersBorderStyleChangedEvent, value); }
2027 public event EventHandler RowHeadersDefaultCellStyleChanged {
2028 add { Events.AddHandler (RowHeadersDefaultCellStyleChangedEvent, value); }
2029 remove { Events.RemoveHandler (RowHeadersDefaultCellStyleChangedEvent, value); }
2032 public event EventHandler RowHeadersWidthChanged {
2033 add { Events.AddHandler (RowHeadersWidthChangedEvent, value); }
2034 remove { Events.RemoveHandler (RowHeadersWidthChangedEvent, value); }
2037 public event DataGridViewAutoSizeModeEventHandler RowHeadersWidthSizeModeChanged {
2038 add { Events.AddHandler (RowHeadersWidthSizeModeChangedEvent, value); }
2039 remove { Events.RemoveHandler (RowHeadersWidthSizeModeChangedEvent, value); }
2042 public event DataGridViewRowEventHandler RowHeightChanged {
2043 add { Events.AddHandler (RowHeightChangedEvent, value); }
2044 remove { Events.RemoveHandler (RowHeightChangedEvent, value); }
2047 [EditorBrowsable (EditorBrowsableState.Advanced)]
2048 public event DataGridViewRowHeightInfoNeededEventHandler RowHeightInfoNeeded {
2049 add { Events.AddHandler (RowHeightInfoNeededEvent, value); }
2050 remove { Events.RemoveHandler (RowHeightInfoNeededEvent, value); }
2053 [EditorBrowsable (EditorBrowsableState.Advanced)]
2054 public event DataGridViewRowHeightInfoPushedEventHandler RowHeightInfoPushed {
2055 add { Events.AddHandler (RowHeightInfoPushedEvent, value); }
2056 remove { Events.RemoveHandler (RowHeightInfoPushedEvent, value); }
2059 public event DataGridViewCellEventHandler RowLeave {
2060 add { Events.AddHandler (RowLeaveEvent, value); }
2061 remove { Events.RemoveHandler (RowLeaveEvent, value); }
2064 public event DataGridViewRowEventHandler RowMinimumHeightChanged {
2065 add { Events.AddHandler (RowMinimumHeightChangedEvent, value); }
2066 remove { Events.RemoveHandler (RowMinimumHeightChangedEvent, value); }
2069 public event DataGridViewRowPostPaintEventHandler RowPostPaint {
2070 add { Events.AddHandler (RowPostPaintEvent, value); }
2071 remove { Events.RemoveHandler (RowPostPaintEvent, value); }
2074 public event DataGridViewRowPrePaintEventHandler RowPrePaint {
2075 add { Events.AddHandler (RowPrePaintEvent, value); }
2076 remove { Events.RemoveHandler (RowPrePaintEvent, value); }
2079 public event DataGridViewRowsAddedEventHandler RowsAdded {
2080 add { Events.AddHandler (RowsAddedEvent, value); }
2081 remove { Events.RemoveHandler (RowsAddedEvent, value); }
2084 public event EventHandler RowsDefaultCellStyleChanged {
2085 add { Events.AddHandler (RowsDefaultCellStyleChangedEvent, value); }
2086 remove { Events.RemoveHandler (RowsDefaultCellStyleChangedEvent, value); }
2089 public event DataGridViewRowsRemovedEventHandler RowsRemoved {
2090 add { Events.AddHandler (RowsRemovedEvent, value); }
2091 remove { Events.RemoveHandler (RowsRemovedEvent, value); }
2094 public event DataGridViewRowStateChangedEventHandler RowStateChanged {
2095 add { Events.AddHandler (RowStateChangedEvent, value); }
2096 remove { Events.RemoveHandler (RowStateChangedEvent, value); }
2099 [EditorBrowsable (EditorBrowsableState.Advanced)]
2100 public event DataGridViewRowEventHandler RowUnshared {
2101 add { Events.AddHandler (RowUnsharedEvent, value); }
2102 remove { Events.RemoveHandler (RowUnsharedEvent, value); }
2105 public event DataGridViewCellEventHandler RowValidated {
2106 add { Events.AddHandler (RowValidatedEvent, value); }
2107 remove { Events.RemoveHandler (RowValidatedEvent, value); }
2110 public event DataGridViewCellCancelEventHandler RowValidating {
2111 add { Events.AddHandler (RowValidatingEvent, value); }
2112 remove { Events.RemoveHandler (RowValidatingEvent, value); }
2115 public event ScrollEventHandler Scroll {
2116 add { Events.AddHandler (ScrollEvent, value); }
2117 remove { Events.RemoveHandler (ScrollEvent, value); }
2120 public event EventHandler SelectionChanged {
2121 add { Events.AddHandler (SelectionChangedEvent, value); }
2122 remove { Events.RemoveHandler (SelectionChangedEvent, value); }
2125 [EditorBrowsable (EditorBrowsableState.Advanced)]
2126 public event DataGridViewSortCompareEventHandler SortCompare {
2127 add { Events.AddHandler (SortCompareEvent, value); }
2128 remove { Events.RemoveHandler (SortCompareEvent, value); }
2131 public event EventHandler Sorted {
2132 add { Events.AddHandler (SortedEvent, value); }
2133 remove { Events.RemoveHandler (SortedEvent, value); }
2136 public event DataGridViewRowEventHandler UserAddedRow {
2137 add { Events.AddHandler (UserAddedRowEvent, value); }
2138 remove { Events.RemoveHandler (UserAddedRowEvent, value); }
2141 public event DataGridViewRowEventHandler UserDeletedRow {
2142 add { Events.AddHandler (UserDeletedRowEvent, value); }
2143 remove { Events.RemoveHandler (UserDeletedRowEvent, value); }
2146 public event DataGridViewRowCancelEventHandler UserDeletingRow {
2147 add { Events.AddHandler (UserDeletingRowEvent, value); }
2148 remove { Events.RemoveHandler (UserDeletingRowEvent, value); }
2152 [EditorBrowsable (EditorBrowsableState.Never)]
2153 public new event EventHandler StyleChanged {
2154 add { base.StyleChanged += value; }
2155 remove { base.StyleChanged -= value; }
2159 [EditorBrowsable (EditorBrowsableState.Never)]
2160 public new event EventHandler TextChanged {
2161 add { base.TextChanged += value; }
2162 remove { base.TextChanged -= value; }
2165 [EditorBrowsable (EditorBrowsableState.Advanced)]
2166 public virtual DataGridViewAdvancedBorderStyle AdjustColumnHeaderBorderStyle (DataGridViewAdvancedBorderStyle dataGridViewAdvancedBorderStyleInput, DataGridViewAdvancedBorderStyle dataGridViewAdvancedBorderStylePlaceholder, bool isFirstDisplayedColumn, bool isLastVisibleColumn) {
2167 return (DataGridViewAdvancedBorderStyle) ((ICloneable)dataGridViewAdvancedBorderStyleInput).Clone();
2170 public bool AreAllCellsSelected (bool includeInvisibleCells) {
2171 foreach (DataGridViewRow row in rows) {
2172 foreach (DataGridViewCell cell in row.Cells) {
2173 if (includeInvisibleCells == false && cell.Visible == false) {
2176 if (!cell.Selected) {
2184 public void AutoResizeColumn (int columnIndex) {
2185 AutoResizeColumn (columnIndex, DataGridViewAutoSizeColumnMode.AllCells);
2188 public void AutoResizeColumn (int columnIndex, DataGridViewAutoSizeColumnMode autoSizeColumnMode)
2190 AutoResizeColumnInternal (columnIndex, autoSizeColumnMode);
2193 public void AutoResizeColumnHeadersHeight ()
2197 foreach (DataGridViewColumn col in Columns)
2198 new_height = Math.Max (new_height, col.HeaderCell.PreferredSize.Height);
2200 if (ColumnHeadersHeight != new_height)
2201 ColumnHeadersHeight = new_height;
2204 [MonoTODO ("columnIndex parameter is not used")]
2205 public void AutoResizeColumnHeadersHeight (int columnIndex)
2207 AutoResizeColumnHeadersHeight ();
2210 public void AutoResizeColumns () {
2211 AutoResizeColumns (DataGridViewAutoSizeColumnsMode.AllCells);
2214 public void AutoResizeColumns (DataGridViewAutoSizeColumnsMode autoSizeColumnsMode) {
2215 AutoResizeColumns (autoSizeColumnsMode, true);
2218 public void AutoResizeRow (int rowIndex)
2220 AutoResizeRow (rowIndex, DataGridViewAutoSizeRowMode.AllCells, true);
2223 public void AutoResizeRow (int rowIndex, DataGridViewAutoSizeRowMode autoSizeRowMode)
2225 AutoResizeRow (rowIndex, autoSizeRowMode, true);
2228 public void AutoResizeRowHeadersWidth (DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode)
2230 if (rowHeadersWidthSizeMode == DataGridViewRowHeadersWidthSizeMode.AutoSizeToFirstHeader) {
2231 RowHeadersWidth = GetRowInternal (0).HeaderCell.PreferredSize.Width;
2237 if (rowHeadersWidthSizeMode == DataGridViewRowHeadersWidthSizeMode.AutoSizeToDisplayedHeaders) {
2238 foreach (DataGridViewRow row in Rows)
2240 new_width = Math.Max (new_width, row.HeaderCell.PreferredSize.Width);
2242 if (RowHeadersWidth != new_width)
2243 RowHeadersWidth = new_width;
2248 if (rowHeadersWidthSizeMode == DataGridViewRowHeadersWidthSizeMode.AutoSizeToAllHeaders) {
2249 foreach (DataGridViewRow row in Rows)
2250 new_width = Math.Max (new_width, row.HeaderCell.PreferredSize.Width);
2252 if (RowHeadersWidth != new_width)
2253 RowHeadersWidth = new_width;
2259 [MonoTODO ("Does not use rowIndex parameter.")]
2260 public void AutoResizeRowHeadersWidth (int rowIndex, DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode)
2262 AutoResizeRowHeadersWidth (rowHeadersWidthSizeMode);
2265 public void AutoResizeRows ()
2267 AutoResizeRows (0, Rows.Count, DataGridViewAutoSizeRowMode.AllCells, false);
2270 public void AutoResizeRows (DataGridViewAutoSizeRowsMode autoSizeRowsMode)
2272 if (!Enum.IsDefined(typeof(DataGridViewAutoSizeRowsMode), autoSizeRowsMode))
2273 throw new InvalidEnumArgumentException ("Parameter autoSizeRowsMode is not a valid DataGridViewRowsMode.");
2274 if ((autoSizeRowsMode == DataGridViewAutoSizeRowsMode.AllHeaders || autoSizeRowsMode == DataGridViewAutoSizeRowsMode.DisplayedHeaders) && rowHeadersVisible == false)
2275 throw new InvalidOperationException ("Parameter autoSizeRowsMode cannot be AllHeaders or DisplayedHeaders in this DataGridView.");
2276 if (autoSizeRowsMode == DataGridViewAutoSizeRowsMode.None)
2277 throw new ArgumentException ("Parameter autoSizeRowsMode cannot be None.");
2279 AutoResizeRows (autoSizeRowsMode, false);
2282 public virtual bool BeginEdit (bool selectAll) {
2283 if (currentCell == null || currentCell.IsInEditMode)
2286 if (currentCell.RowIndex >= 0) {
2287 if ((currentCell.InheritedState & DataGridViewElementStates.ReadOnly) == DataGridViewElementStates.ReadOnly) {
2292 DataGridViewCell cell = currentCell;
2293 Type editType = cell.EditType;
2295 if (editType == null && !(cell is IDataGridViewEditingCell))
2298 // Give user a chance to cancel the edit
2299 DataGridViewCellCancelEventArgs e = new DataGridViewCellCancelEventArgs (cell.ColumnIndex, cell.RowIndex);
2300 OnCellBeginEdit (e);
2305 cell.SetIsInEditMode (true);
2307 // The cell has an editing control we need to setup
2308 if (editType != null) {
2309 Control ctrl = EditingControlInternal;
2311 // Check if we can reuse the one we already have
2312 bool isCorrectType = ctrl != null && ctrl.GetType () == editType;
2317 // We couldn't use the existing one, create a new one
2319 ctrl = (Control) Activator.CreateInstance (editType);
2320 EditingControlInternal = ctrl;
2323 // Call some functions that allows the editing control to get setup
2324 DataGridViewCellStyle style = cell.RowIndex == -1 ? DefaultCellStyle : cell.InheritedStyle;
2326 cell.InitializeEditingControl (cell.RowIndex, cell.FormattedValue, style);
2327 cell.PositionEditingControl (true, true, this.GetCellDisplayRectangle (cell.ColumnIndex, cell.RowIndex, false), bounds, style, false, false, (columns [cell.ColumnIndex].DisplayIndex == 0), (cell.RowIndex == 0));
2329 // Show the editing control
2330 if (EditingControlInternal != null)
2331 EditingControlInternal.Visible = true;
2333 IDataGridViewEditingControl dgvEditingControl = (IDataGridViewEditingControl) EditingControlInternal;
2334 if (dgvEditingControl != null) {
2335 dgvEditingControl.EditingControlDataGridView = this;
2336 dgvEditingControl.EditingControlRowIndex = currentCell.OwningRow.Index;
2337 dgvEditingControl.ApplyCellStyleToEditingControl (style);
2338 dgvEditingControl.PrepareEditingControlForEdit (selectAll);
2339 dgvEditingControl.EditingControlFormattedValue = currentCell.EditedFormattedValue;
2344 // If we are here, it means we have a cell that does not have an editing control
2345 // and simply implements IDataGridViewEditingCell itself.
2346 (cell as IDataGridViewEditingCell).PrepareEditingCellForEdit (selectAll);
2351 public bool CancelEdit ()
2353 if (currentCell != null) {
2354 if (currentCell.IsInEditMode) {
2355 currentCell.SetIsInEditMode (false);
2356 currentCell.DetachEditingControl ();
2359 if (currentCell.RowIndex == NewRowIndex) {
2360 if (DataManager != null)
2361 DataManager.CancelCurrentEdit ();
2363 new_row_editing = false;
2364 PrepareEditingRow (false, false);
2365 MoveCurrentCell (currentCell.ColumnIndex, NewRowIndex, true, false, false, true);
2366 OnUserDeletedRow (new DataGridViewRowEventArgs (EditingRow));
2373 public void ClearSelection ()
2375 foreach (DataGridViewColumn col in SelectedColumns)
2376 col.Selected = false;
2377 foreach (DataGridViewRow row in SelectedRows)
2378 row.Selected = false;
2379 foreach (DataGridViewCell cell in SelectedCells)
2380 cell.Selected = false;
2383 public bool CommitEdit (DataGridViewDataErrorContexts context)
2385 if (currentCell == null)
2390 object newValue = currentCell.ParseFormattedValue (currentCell.EditedFormattedValue,
2391 currentCell.InheritedStyle, null, null);
2393 DataGridViewCellValidatingEventArgs validateArgs = new DataGridViewCellValidatingEventArgs (currentCell.ColumnIndex,
2394 currentCell.RowIndex,
2397 OnCellValidating (validateArgs);
2398 if (validateArgs.Cancel)
2400 OnCellValidated (new DataGridViewCellEventArgs (currentCell.ColumnIndex, currentCell.RowIndex));
2403 currentCell.Value = newValue;
2405 } catch (Exception e) {
2406 DataGridViewDataErrorEventArgs args = new DataGridViewDataErrorEventArgs (e, currentCell.ColumnIndex, currentCell.RowIndex,
2407 DataGridViewDataErrorContexts.Commit);
2408 OnDataError (false, args);
2409 if (args.ThrowException)
2416 public int DisplayedColumnCount (bool includePartialColumns)
2421 if (RowHeadersVisible)
2422 columnLeft += RowHeadersWidth;
2424 Size visibleClientArea = ClientSize;
2425 if (verticalScrollBar.Visible)
2426 visibleClientArea.Width -= verticalScrollBar.Width;
2427 if (horizontalScrollBar.Visible)
2428 visibleClientArea.Height -= horizontalScrollBar.Height;
2430 for (int index = first_col_index; index < Columns.Count; index++) {
2431 DataGridViewColumn column = Columns[ColumnDisplayIndexToIndex (index)];
2432 if (columnLeft + column.Width <= visibleClientArea.Width) {
2434 columnLeft += column.Width;
2436 if (includePartialColumns)
2445 public int DisplayedRowCount (bool includePartialRow)
2450 if (ColumnHeadersVisible)
2451 rowTop += ColumnHeadersHeight;
2453 Size visibleClientArea = ClientSize;
2454 if (verticalScrollBar.Visible)
2455 visibleClientArea.Width -= verticalScrollBar.Width;
2456 if (horizontalScrollBar.Visible)
2457 visibleClientArea.Height -= horizontalScrollBar.Height;
2459 for (int index = first_row_index; index < Rows.Count; index++) {
2460 DataGridViewRow row = GetRowInternal (index);
2461 if (rowTop + row.Height <= visibleClientArea.Height) {
2463 rowTop += row.Height;
2465 if (includePartialRow)
2474 public bool EndEdit ()
2476 return EndEdit (DataGridViewDataErrorContexts.Commit);
2479 [MonoTODO ("Does not use context parameter")]
2480 public bool EndEdit (DataGridViewDataErrorContexts context)
2482 if (currentCell == null || !currentCell.IsInEditMode)
2485 if (!CommitEdit (context)) {
2486 if (DataManager != null)
2487 DataManager.EndCurrentEdit ();
2488 if (EditingControl != null)
2489 EditingControl.Focus ();
2493 currentCell.SetIsInEditMode (false);
2494 currentCell.DetachEditingControl ();
2495 OnCellEndEdit (new DataGridViewCellEventArgs (currentCell.ColumnIndex, currentCell.RowIndex));
2497 if (currentCell.RowIndex == NewRowIndex) {
2498 new_row_editing = false;
2499 editing_row = null; // editing row becomes a real row
2500 PrepareEditingRow (true, false); // add a new editing row
2501 MoveCurrentCell (currentCell.ColumnIndex, NewRowIndex, true, false, false, true);
2506 public int GetCellCount (DataGridViewElementStates includeFilter) {
2508 foreach (DataGridViewRow row in rows) {
2509 foreach (DataGridViewCell cell in row.Cells) {
2510 if ((cell.State & includeFilter) != 0) {
2518 internal DataGridViewRow GetRowInternal (int rowIndex)
2520 return Rows.SharedRow (rowIndex);
2523 internal DataGridViewCell GetCellInternal (int colIndex, int rowIndex)
2525 return GetRowInternal (rowIndex).Cells.GetCellInternal (colIndex);
2528 public Rectangle GetCellDisplayRectangle (int columnIndex, int rowIndex, bool cutOverflow) {
2529 if (columnIndex < 0 || columnIndex >= columns.Count) {
2530 throw new ArgumentOutOfRangeException("Column index is out of range.");
2533 int x = 0, y = 0, w = 0, h = 0;
2538 if (ColumnHeadersVisible)
2539 y += ColumnHeadersHeight;
2541 if (RowHeadersVisible)
2542 x += RowHeadersWidth;
2544 List<DataGridViewColumn> cols = columns.ColumnDisplayIndexSortedArrayList;
2546 for (int i = first_col_index; i < cols.Count; i++) {
2547 if (!cols[i].Visible)
2550 if (cols[i].Index == columnIndex) {
2558 for (int i = first_row_index; i < Rows.Count; i++) {
2559 if (!rows[i].Visible)
2562 if (rows[i].Index == rowIndex) {
2563 h = rows [i].Height;
2567 y += rows [i].Height;
2570 return new Rectangle (x, y, w, h);
2573 public virtual DataObject GetClipboardContent () {
2575 if (clipboardCopyMode == DataGridViewClipboardCopyMode.Disable)
2576 throw new InvalidOperationException ("Generating Clipboard content is not supported when the ClipboardCopyMode property is Disable.");
2578 int start_row = int.MaxValue, end_row = int.MinValue;
2579 int start_col = int.MaxValue, end_col = int.MinValue;
2581 bool include_row_headers = false;
2582 bool include_col_headers = false;
2583 bool only_included_headers = false;
2584 bool headers_includable = false;
2586 switch (ClipboardCopyMode) {
2587 case DataGridViewClipboardCopyMode.EnableWithoutHeaderText:
2589 case DataGridViewClipboardCopyMode.EnableWithAutoHeaderText:
2590 // Headers are included if not selection mode is CellSelect, and any header is selected.
2591 headers_includable = selectionMode != DataGridViewSelectionMode.CellSelect;
2593 case DataGridViewClipboardCopyMode.EnableAlwaysIncludeHeaderText:
2594 include_col_headers = include_row_headers = true;
2598 BitArray included_rows = new BitArray (RowCount);
2599 BitArray included_cols = new BitArray (ColumnCount);
2601 // If there are any selected columns,
2602 // include the column headers (if headers are to be shown).
2603 if (headers_includable && !include_col_headers) {
2604 for (int c = 0; c < ColumnCount; c++) {
2605 if (Columns [c].Selected) {
2606 include_col_headers = true;
2612 // Find the smallest rectangle that encompasses all selected cells.
2613 for (int r = 0; r < RowCount; r++) {
2614 DataGridViewRow row = Rows [r];
2616 if (headers_includable && !include_row_headers && row.Selected) {
2617 include_row_headers = true;
2620 for (int c = 0; c < ColumnCount; c++) {
2621 DataGridViewCell cell = row.Cells [c];
2623 if (cell == null || !cell.Selected)
2626 included_cols [c] = true;
2627 included_rows [r] = true;
2629 start_row = Math.Min (start_row, r);
2630 start_col = Math.Min (start_col, c);
2631 end_row = Math.Max (end_row, r);
2632 end_col = Math.Max (end_col, c);
2636 // Mark rows/columns in between selected cells as included if the selection mode isn't FullHeaderSelect.
2637 switch (selectionMode){
2638 case DataGridViewSelectionMode.CellSelect:
2639 case DataGridViewSelectionMode.ColumnHeaderSelect:
2640 case DataGridViewSelectionMode.RowHeaderSelect:
2641 if (selectionMode != DataGridViewSelectionMode.ColumnHeaderSelect) {
2642 for (int r = start_row; r <= end_row; r++) {
2643 included_rows.Set (r, true);
2645 } else if (start_row <= end_row) {
2646 included_rows.SetAll (true);
2648 if (selectionMode != DataGridViewSelectionMode.RowHeaderSelect) {
2649 for (int c = start_col; c <= end_col; c++) {
2650 included_cols.Set (c, true);
2654 case DataGridViewSelectionMode.FullColumnSelect:
2655 case DataGridViewSelectionMode.FullRowSelect:
2656 only_included_headers = true;
2660 if (start_row > end_row)
2663 if (start_col > end_col)
2666 DataObject result = new DataObject ();
2668 System.Text.StringBuilder text_builder = new System.Text.StringBuilder ();
2669 System.Text.StringBuilder utext_builder = new System.Text.StringBuilder ();
2670 System.Text.StringBuilder html_builder = new System.Text.StringBuilder ();
2671 System.Text.StringBuilder csv_builder = new System.Text.StringBuilder ();
2673 // Loop through all rows and columns to create the content.
2674 // -1 is the header row/column.
2675 int first_row = start_row;
2676 int first_col = start_col;
2677 if (include_col_headers) {
2680 for (int r = first_row; r <= end_row; r++) {
2681 DataGridViewRow row = null;
2684 if (!included_rows [r])
2690 if (include_row_headers) {
2694 for (int c = first_col; c <= end_col; c++) {
2695 DataGridViewCell cell = null;
2697 if (c >= 0 && only_included_headers && !included_cols [c])
2702 cell = TopLeftHeaderCell;
2704 cell = Columns [c].HeaderCell;
2708 cell = row.HeaderCell;
2710 cell = row.Cells [c];
2714 string text, utext, html, csv;
2715 bool is_first_cell = (c == first_col);
2716 bool is_last_cell = (c == end_col);
2717 bool is_first_row = (r == first_row);
2718 bool is_last_row = (r == end_row);
2721 text = string.Empty;
2722 utext = string.Empty;
2723 html = string.Empty;
2726 text = cell.GetClipboardContentInternal (r, is_first_cell, is_last_cell, is_first_row, is_last_row, DataFormats.Text) as string;
2727 utext = cell.GetClipboardContentInternal (r, is_first_cell, is_last_cell, is_first_row, is_last_row, DataFormats.UnicodeText) as string;
2728 html = cell.GetClipboardContentInternal (r, is_first_cell, is_last_cell, is_first_row, is_last_row, DataFormats.Html) as string;
2729 csv = cell.GetClipboardContentInternal (r, is_first_cell, is_last_cell, is_first_row, is_last_row, DataFormats.CommaSeparatedValue) as string;
2732 text_builder.Append (text);
2733 utext_builder.Append (utext);
2734 html_builder.Append (html);
2735 csv_builder.Append (csv);
2737 if (c == -1) { // If we just did the row header, jump to the first column.
2742 if (r == -1) {// If we just did the column header, jump to the first row.
2748 // Html content always get the \r\n newline
2749 // It's valid html anyway, and it eases testing quite a bit
2750 // (since otherwise we'd have to change the start indices
2751 // in the added prologue/epilogue text)
2753 int fragment_end = 135 + html_builder.Length;
2754 int html_end = fragment_end + 36;
2757 "StartHTML:00000097{0}" +
2758 "EndHTML:{1:00000000}{0}" +
2759 "StartFragment:00000133{0}" +
2760 "EndFragment:{2:00000000}{0}" +
2763 "<!--StartFragment-->";
2765 html_start = string.Format (html_start, "\r\n", html_end, fragment_end);
2766 html_builder.Insert (0, html_start);
2767 html_builder.AppendFormat ("{0}<!--EndFragment-->{0}</BODY>{0}</HTML>", "\r\n");
2769 result.SetData (DataFormats.CommaSeparatedValue, false, csv_builder.ToString ());
2770 result.SetData (DataFormats.Html, false, html_builder.ToString ());
2771 result.SetData (DataFormats.UnicodeText, false, utext_builder.ToString ());
2772 result.SetData (DataFormats.Text, false, text_builder.ToString ());
2777 [MonoTODO ("Does not use cutOverflow parameter")]
2778 public Rectangle GetColumnDisplayRectangle (int columnIndex, bool cutOverflow)
2780 if (columnIndex < 0 || columnIndex > Columns.Count - 1)
2781 throw new ArgumentOutOfRangeException ("columnIndex");
2788 if (RowHeadersVisible)
2789 x += RowHeadersWidth;
2791 List<DataGridViewColumn> cols = columns.ColumnDisplayIndexSortedArrayList;
2793 for (int i = first_col_index; i < cols.Count; i++) {
2794 if (!cols[i].Visible)
2797 if (cols[i].Index == columnIndex) {
2805 return new Rectangle (x, 0, w, Height);
2808 [MonoTODO ("Does not use cutOverflow parameter")]
2809 public Rectangle GetRowDisplayRectangle (int rowIndex, bool cutOverflow)
2811 if (rowIndex < 0 || rowIndex > Rows.Count - 1)
2812 throw new ArgumentOutOfRangeException ("rowIndex");
2819 if (ColumnHeadersVisible)
2820 y += ColumnHeadersHeight;
2823 for (int i = first_row_index; i < Rows.Count; i++) {
2824 if (!rows[i].Visible)
2827 if (rows[i].Index == rowIndex) {
2828 h = rows [i].Height;
2832 y += rows [i].Height;
2835 return new Rectangle (0, y, Width, h);
2838 public HitTestInfo HitTest (int x, int y) {
2839 ///////////////////////////////////////////////////////
2840 //Console.WriteLine ("HitTest ({0}, {1})", x, y);
2841 bool isInColHeader = columnHeadersVisible && y >= 0 && y <= ColumnHeadersHeight;
2842 bool isInRowHeader = rowHeadersVisible && x >= 0 && x <= RowHeadersWidth;
2845 if (isInColHeader && isInRowHeader)
2846 return new HitTestInfo (-1, x, -1, y, DataGridViewHitTestType.TopLeftHeader);
2848 // HorizontalScrollBar
2849 if (horizontalScrollBar.Visible && horizontalScrollBar.Bounds.Contains (x, y))
2850 return new HitTestInfo (-1, x, -1, y, DataGridViewHitTestType.HorizontalScrollBar);
2852 // VerticalScrollBar
2853 if (verticalScrollBar.Visible && verticalScrollBar.Bounds.Contains (x, y))
2854 return new HitTestInfo (-1, x, -1, y, DataGridViewHitTestType.VerticalScrollBar);
2856 // The little box in the bottom right if both scrollbars are shown is None
2857 if (verticalScrollBar.Visible && horizontalScrollBar.Visible)
2858 if (new Rectangle (verticalScrollBar.Left, horizontalScrollBar.Top, verticalScrollBar.Width, horizontalScrollBar.Height).Contains (x, y))
2859 return new HitTestInfo (-1, x, -1, y, DataGridViewHitTestType.None);
2864 int top = columnHeadersVisible ? columnHeadersHeight : 0;
2866 for (int i = first_row_index; i < Rows.Count; i++) {
2867 DataGridViewRow row = Rows[i];
2871 if (y > top && y <= (top + row.Height)) {
2879 int left = rowHeadersVisible ? RowHeadersWidth : 0;
2881 List<DataGridViewColumn> cols = columns.ColumnDisplayIndexSortedArrayList;
2883 for (int i = first_col_index; i < cols.Count; i++) {
2884 if (!cols[i].Visible)
2887 if (x > left && x <= (left + cols[i].Width)) {
2888 colindex = cols[i].Index;
2892 left += cols[i].Width;
2895 if (colindex >= 0 && rowindex >= 0)
2896 return new HitTestInfo (colindex, x, rowindex, y, DataGridViewHitTestType.Cell);
2898 if (isInColHeader && colindex > -1)
2899 return new HitTestInfo (colindex, x, rowindex, y, DataGridViewHitTestType.ColumnHeader);
2901 if (isInRowHeader && rowindex > -1)
2902 return new HitTestInfo (colindex, x, rowindex, y, DataGridViewHitTestType.RowHeader);
2904 return new HitTestInfo (-1, x, -1, y, DataGridViewHitTestType.None);
2907 public void InvalidateCell (DataGridViewCell dataGridViewCell)
2909 if (dataGridViewCell == null)
2910 throw new ArgumentNullException ("Cell is null");
2912 if (dataGridViewCell.DataGridView != this)
2913 throw new ArgumentException ("The specified cell does not belong to this DataGridView.");
2915 InvalidateCell (dataGridViewCell.ColumnIndex, dataGridViewCell.RowIndex);
2918 public void InvalidateCell (int columnIndex, int rowIndex)
2920 if (columnIndex < 0 || columnIndex >= columns.Count)
2921 throw new ArgumentOutOfRangeException ("Column index is out of range.");
2923 if (rowIndex < 0 || rowIndex >= rows.Count)
2924 throw new ArgumentOutOfRangeException ("Row index is out of range.");
2927 Invalidate (GetCellDisplayRectangle (columnIndex, rowIndex, true));
2930 public void InvalidateColumn (int columnIndex)
2932 if (columnIndex < 0 || columnIndex >= columns.Count)
2933 throw new ArgumentOutOfRangeException ("Column index is out of range.");
2936 Invalidate (GetColumnDisplayRectangle (columnIndex, true));
2939 public void InvalidateRow (int rowIndex)
2941 if (rowIndex < 0 || rowIndex >= rows.Count)
2942 throw new ArgumentOutOfRangeException ("Row index is out of range.");
2945 Invalidate (GetRowDisplayRectangle (rowIndex, true));
2948 public virtual void NotifyCurrentCellDirty (bool dirty) {
2949 if (currentCell != null)
2950 InvalidateCell (currentCell);
2953 public bool RefreshEdit ()
2955 if (IsCurrentCellInEditMode) {
2956 currentCell.InitializeEditingControl (currentCell.RowIndex, currentCell.FormattedValue, currentCell.InheritedStyle);
2963 [EditorBrowsable (EditorBrowsableState.Never)]
2964 public override void ResetText ()
2966 Text = string.Empty;
2969 public void SelectAll () {
2970 switch (selectionMode) {
2971 case DataGridViewSelectionMode.FullRowSelect:
2972 foreach (DataGridViewRow row in rows) {
2973 (row as DataGridViewBand).Selected = true;
2976 case DataGridViewSelectionMode.FullColumnSelect:
2977 foreach (DataGridViewColumn col in columns) {
2978 (col as DataGridViewBand).Selected = true;
2982 foreach (DataGridViewRow row in rows) {
2983 foreach (DataGridViewCell cell in row.Cells) {
2984 cell.Selected = true;
2993 public virtual void Sort (IComparer comparer)
2995 if (comparer == null)
2996 throw new ArgumentNullException ("comparer");
2997 if (VirtualMode || DataSource != null)
2998 throw new InvalidOperationException ();
3000 if (SortedColumn != null)
3001 SortedColumn.HeaderCell.SortGlyphDirection = SortOrder.None;
3005 Rows.Sort (comparer);
3007 sortedColumn = null;
3008 sortOrder = SortOrder.None;
3014 OnSorted (EventArgs.Empty);
3017 public virtual void Sort (DataGridViewColumn dataGridViewColumn, ListSortDirection direction)
3019 if (dataGridViewColumn == null)
3020 throw new ArgumentNullException ("dataGridViewColumn");
3021 if (dataGridViewColumn.DataGridView != this)
3022 throw new ArgumentException ("dataGridViewColumn");
3027 if (SortedColumn != null)
3028 SortedColumn.HeaderCell.SortGlyphDirection = SortOrder.None;
3030 sortedColumn = dataGridViewColumn;
3031 sortOrder = direction == ListSortDirection.Ascending ? SortOrder.Ascending : SortOrder.Descending;
3033 if (Rows.Count == 0)
3036 if (dataGridViewColumn.IsDataBound) {
3037 IBindingList bindingList = DataManager.List as IBindingList;
3038 if (bindingList != null && bindingList.SupportsSorting) {
3039 bindingList.ApplySort (DataManager.GetItemProperties()[dataGridViewColumn.DataPropertyName], direction);
3040 dataGridViewColumn.HeaderCell.SortGlyphDirection = sortOrder;
3043 // Figure out if this is a numeric sort or text sort
3044 bool is_numeric = true;
3047 foreach (DataGridViewRow row in Rows) {
3048 object val = row.Cells[dataGridViewColumn.Index].Value;
3050 if (val != null && !double.TryParse (val.ToString (), out n)) {
3056 ColumnSorter sorter = new ColumnSorter (dataGridViewColumn, direction, is_numeric);
3058 dataGridViewColumn.HeaderCell.SortGlyphDirection = sortOrder;
3062 OnSorted (EventArgs.Empty);
3065 public void UpdateCellErrorText (int columnIndex, int rowIndex)
3067 if (columnIndex < 0 || columnIndex > Columns.Count - 1)
3068 throw new ArgumentOutOfRangeException ("columnIndex");
3069 if (rowIndex < 0 || rowIndex > Rows.Count - 1)
3070 throw new ArgumentOutOfRangeException ("rowIndex");
3072 InvalidateCell (columnIndex, rowIndex);
3075 public void UpdateCellValue (int columnIndex, int rowIndex)
3077 if (columnIndex < 0 || columnIndex > Columns.Count - 1)
3078 throw new ArgumentOutOfRangeException ("columnIndex");
3079 if (rowIndex < 0 || rowIndex > Rows.Count - 1)
3080 throw new ArgumentOutOfRangeException ("rowIndex");
3082 InvalidateCell (columnIndex, rowIndex);
3085 public void UpdateRowErrorText (int rowIndex)
3087 if (rowIndex < 0 || rowIndex > Rows.Count - 1)
3088 throw new ArgumentOutOfRangeException ("rowIndex");
3090 InvalidateRow (rowIndex);
3093 public void UpdateRowErrorText (int rowIndexStart, int rowIndexEnd)
3095 if (rowIndexStart < 0 || rowIndexStart > Rows.Count - 1)
3096 throw new ArgumentOutOfRangeException ("rowIndexStart");
3097 if (rowIndexEnd < 0 || rowIndexEnd > Rows.Count - 1)
3098 throw new ArgumentOutOfRangeException ("rowIndexEnd");
3099 if (rowIndexEnd < rowIndexStart)
3100 throw new ArgumentOutOfRangeException ("rowIndexEnd", "rowIndexEnd must be greater than rowIndexStart");
3102 for (int i = rowIndexStart; i <= rowIndexEnd; i++)
3106 public void UpdateRowHeightInfo (int rowIndex, bool updateToEnd)
3108 if (rowIndex < 0 && updateToEnd)
3109 throw new ArgumentOutOfRangeException ("rowIndex");
3110 if (rowIndex < -1 && !updateToEnd)
3111 throw new ArgumentOutOfRangeException ("rowIndex");
3112 if (rowIndex >= Rows.Count)
3113 throw new ArgumentOutOfRangeException ("rowIndex");
3115 if (!VirtualMode && DataManager == null)
3118 if (rowIndex == -1) {
3124 for (int i = rowIndex; i < Rows.Count; i++) {
3125 DataGridViewRow row = Rows[i];
3129 DataGridViewRowHeightInfoNeededEventArgs rowInfo =
3130 new DataGridViewRowHeightInfoNeededEventArgs (row.Index, row.Height, row.MinimumHeight);
3131 OnRowHeightInfoNeeded (rowInfo);
3133 if (row.Height != rowInfo.Height || row.MinimumHeight != rowInfo.MinimumHeight) {
3134 row.Height = rowInfo.Height;
3135 row.MinimumHeight = rowInfo.MinimumHeight;
3136 OnRowHeightInfoPushed (new DataGridViewRowHeightInfoPushedEventArgs (row.Index, rowInfo.Height,
3137 rowInfo.MinimumHeight));
3141 DataGridViewRow row = Rows[rowIndex];
3142 DataGridViewRowHeightInfoNeededEventArgs rowInfo =
3143 new DataGridViewRowHeightInfoNeededEventArgs (row.Index, row.Height, row.MinimumHeight);
3144 OnRowHeightInfoNeeded (rowInfo);
3146 if (row.Height != rowInfo.Height || row.MinimumHeight != rowInfo.MinimumHeight) {
3147 row.Height = rowInfo.Height;
3148 row.MinimumHeight = rowInfo.MinimumHeight;
3149 OnRowHeightInfoPushed (new DataGridViewRowHeightInfoPushedEventArgs (row.Index, rowInfo.Height,
3150 rowInfo.MinimumHeight));
3155 protected override bool CanEnableIme {
3157 if (CurrentCell != null && CurrentCell.EditType != null)
3164 protected override Size DefaultSize {
3165 get { return new Size (240, 150); }
3168 protected ScrollBar HorizontalScrollBar {
3169 get { return horizontalScrollBar; }
3172 protected ScrollBar VerticalScrollBar {
3173 get { return verticalScrollBar; }
3176 protected virtual void AccessibilityNotifyCurrentCellChanged (Point cellAddress)
3178 throw new NotImplementedException ();
3181 [MonoTODO ("Does not use fixedHeight parameter")]
3182 protected void AutoResizeColumn (int columnIndex, DataGridViewAutoSizeColumnMode autoSizeColumnMode, bool fixedHeight)
3184 AutoResizeColumn (columnIndex, autoSizeColumnMode);
3187 [MonoTODO ("Does not use fixedRowHeadersWidth or fixedColumnsWidth parameters")]
3188 protected void AutoResizeColumnHeadersHeight (bool fixedRowHeadersWidth, bool fixedColumnsWidth)
3190 AutoResizeColumnHeadersHeight ();
3193 [MonoTODO ("Does not use columnIndex or fixedRowHeadersWidth or fixedColumnsWidth parameters")]
3194 protected void AutoResizeColumnHeadersHeight (int columnIndex, bool fixedRowHeadersWidth, bool fixedColumnWidth)
3196 AutoResizeColumnHeadersHeight (columnIndex);
3199 protected void AutoResizeColumns (DataGridViewAutoSizeColumnsMode autoSizeColumnsMode, bool fixedHeight) {
3200 for (int i = 0; i < Columns.Count; i++) {
3201 AutoResizeColumn (i, (DataGridViewAutoSizeColumnMode) autoSizeColumnsMode, fixedHeight);
3205 [MonoTODO ("Does not use fixedWidth parameter")]
3206 protected void AutoResizeRow (int rowIndex, DataGridViewAutoSizeRowMode autoSizeRowMode, bool fixedWidth)
3208 if (autoSizeRowMode == DataGridViewAutoSizeRowMode.RowHeader && !rowHeadersVisible)
3209 throw new InvalidOperationException ("row headers are not visible");
3210 if (rowIndex < 0 || rowIndex > Rows.Count - 1)
3211 throw new ArgumentOutOfRangeException ("rowIndex");
3213 DataGridViewRow row = GetRowInternal (rowIndex);
3215 int new_height = row.GetPreferredHeight (rowIndex, autoSizeRowMode, true);
3217 if (row.Height != new_height)
3218 row.SetAutoSizeHeight (new_height);
3221 [MonoTODO ("Does not use fixedColumnHeadersHeight or fixedRowsHeight parameter")]
3222 protected void AutoResizeRowHeadersWidth (DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode, bool fixedColumnHeadersHeight, bool fixedRowsHeight)
3224 AutoResizeRowHeadersWidth (rowHeadersWidthSizeMode);
3227 [MonoTODO ("Does not use rowIndex or fixedColumnHeadersHeight or fixedRowsHeight parameter")]
3228 protected void AutoResizeRowHeadersWidth (int rowIndex, DataGridViewRowHeadersWidthSizeMode rowHeadersWidthSizeMode, bool fixedColumnHeadersHeight, bool fixedRowHeight)
3230 AutoResizeRowHeadersWidth (rowHeadersWidthSizeMode);
3233 [MonoTODO ("Does not use fixedWidth parameter")]
3234 protected void AutoResizeRows (DataGridViewAutoSizeRowsMode autoSizeRowsMode, bool fixedWidth)
3236 if (autoSizeRowsMode == DataGridViewAutoSizeRowsMode.None)
3239 bool displayed_only = false;
3240 DataGridViewAutoSizeRowMode mode = DataGridViewAutoSizeRowMode.AllCells;
3242 switch (autoSizeRowsMode) {
3243 case DataGridViewAutoSizeRowsMode.AllHeaders:
3244 mode = DataGridViewAutoSizeRowMode.RowHeader;
3246 case DataGridViewAutoSizeRowsMode.AllCellsExceptHeaders:
3247 mode = DataGridViewAutoSizeRowMode.AllCellsExceptHeader;
3249 case DataGridViewAutoSizeRowsMode.AllCells:
3250 mode = DataGridViewAutoSizeRowMode.AllCells;
3252 case DataGridViewAutoSizeRowsMode.DisplayedHeaders:
3253 mode = DataGridViewAutoSizeRowMode.RowHeader;
3254 displayed_only = true;
3256 case DataGridViewAutoSizeRowsMode.DisplayedCellsExceptHeaders:
3257 mode = DataGridViewAutoSizeRowMode.AllCellsExceptHeader;
3258 displayed_only = true;
3260 case DataGridViewAutoSizeRowsMode.DisplayedCells:
3261 mode = DataGridViewAutoSizeRowMode.AllCells;
3262 displayed_only = true;
3266 foreach (DataGridViewRow row in Rows) {
3269 if (!displayed_only || row.Displayed) {
3270 int new_height = row.GetPreferredHeight (row.Index, mode, fixedWidth);
3272 if (row.Height != new_height)
3273 row.SetAutoSizeHeight (new_height);
3278 [MonoTODO ("Does not use fixedMode parameter")]
3279 protected void AutoResizeRows (int rowIndexStart, int rowsCount, DataGridViewAutoSizeRowMode autoSizeRowMode, bool fixedWidth)
3281 for (int i = rowIndexStart; i < rowIndexStart + rowsCount; i++)
3282 AutoResizeRow (i, autoSizeRowMode, fixedWidth);
3285 protected void ClearSelection (int columnIndexException, int rowIndexException, bool selectExceptionElement) {
3286 if (columnIndexException >= columns.Count) {
3287 throw new ArgumentOutOfRangeException("ColumnIndexException is greater than the highest column index.");
3289 if (selectionMode == DataGridViewSelectionMode.FullRowSelect) {
3290 if (columnIndexException < -1) {
3291 throw new ArgumentOutOfRangeException("ColumnIndexException is less than -1.");
3295 if (columnIndexException < 0) {
3296 throw new ArgumentOutOfRangeException("ColumnIndexException is less than 0.");
3299 if (rowIndexException >= rows.Count) {
3300 throw new ArgumentOutOfRangeException("RowIndexException is greater than the highest row index.");
3302 if (selectionMode == DataGridViewSelectionMode.FullColumnSelect) {
3303 if (rowIndexException < -1) {
3304 throw new ArgumentOutOfRangeException("RowIndexException is less than -1.");
3308 if (rowIndexException < 0) {
3309 throw new ArgumentOutOfRangeException("RowIndexException is less than 0.");
3312 switch (selectionMode) {
3313 case DataGridViewSelectionMode.FullRowSelect:
3314 foreach (DataGridViewRow row in rows) {
3315 if (selectExceptionElement && row.Index == rowIndexException) {
3318 SetSelectedRowCore (row.Index, false);
3321 case DataGridViewSelectionMode.FullColumnSelect:
3322 foreach (DataGridViewColumn col in columns) {
3323 if (selectExceptionElement && col.Index == columnIndexException) {
3326 SetSelectedColumnCore (col.Index, false);
3330 foreach (DataGridViewCell cell in SelectedCells) {
3331 if (selectExceptionElement && cell.RowIndex == rowIndexException && cell.ColumnIndex == columnIndexException) {
3334 SetSelectedCellCore (cell.ColumnIndex, cell.RowIndex, false);
3340 protected override AccessibleObject CreateAccessibilityInstance ()
3342 return new DataGridViewAccessibleObject(this);
3345 [EditorBrowsable (EditorBrowsableState.Advanced)]
3346 protected virtual DataGridViewColumnCollection CreateColumnsInstance ()
3348 return new DataGridViewColumnCollection(this);
3351 protected override Control.ControlCollection CreateControlsInstance ()
3353 return new DataGridViewControlCollection (this);
3356 [EditorBrowsable (EditorBrowsableState.Advanced)]
3357 protected virtual DataGridViewRowCollection CreateRowsInstance ()
3359 return new DataGridViewRowCollection(this);
3362 protected override void Dispose (bool disposing) {
3365 protected override AccessibleObject GetAccessibilityObjectById (int objectId)
3367 throw new NotImplementedException();
3370 protected override bool IsInputChar (char charCode)
3375 protected override bool IsInputKey (Keys keyData)
3377 // Don't look at the modifiers
3378 keyData = keyData & ~Keys.Modifiers;
3400 protected virtual void OnAllowUserToAddRowsChanged (EventArgs e)
3402 EventHandler eh = (EventHandler)(Events [AllowUserToAddRowsChangedEvent]);
3407 protected virtual void OnAllowUserToDeleteRowsChanged (EventArgs e)
3409 EventHandler eh = (EventHandler)(Events [AllowUserToDeleteRowsChangedEvent]);
3414 protected virtual void OnAllowUserToOrderColumnsChanged (EventArgs e)
3416 EventHandler eh = (EventHandler)(Events [AllowUserToOrderColumnsChangedEvent]);
3421 protected virtual void OnAllowUserToResizeColumnsChanged (EventArgs e)
3423 EventHandler eh = (EventHandler)(Events [AllowUserToResizeColumnsChangedEvent]);
3428 protected virtual void OnAllowUserToResizeRowsChanged (EventArgs e)
3430 EventHandler eh = (EventHandler)(Events [AllowUserToResizeRowsChangedEvent]);
3435 protected virtual void OnAlternatingRowsDefaultCellStyleChanged (EventArgs e)
3437 EventHandler eh = (EventHandler)(Events [AlternatingRowsDefaultCellStyleChangedEvent]);
3442 protected virtual void OnAutoGenerateColumnsChanged (EventArgs e)
3444 EventHandler eh = (EventHandler)(Events [AutoGenerateColumnsChangedEvent]);
3449 protected internal virtual void OnAutoSizeColumnModeChanged (DataGridViewAutoSizeColumnModeEventArgs e)
3451 DataGridViewAutoSizeColumnModeEventHandler eh = (DataGridViewAutoSizeColumnModeEventHandler)(Events [AutoSizeColumnModeChangedEvent]);
3456 protected virtual void OnAutoSizeColumnsModeChanged (DataGridViewAutoSizeColumnsModeEventArgs e)
3458 DataGridViewAutoSizeColumnsModeEventHandler eh = (DataGridViewAutoSizeColumnsModeEventHandler)(Events [AutoSizeColumnsModeChangedEvent]);
3463 protected virtual void OnAutoSizeRowsModeChanged (DataGridViewAutoSizeModeEventArgs e)
3465 DataGridViewAutoSizeModeEventHandler eh = (DataGridViewAutoSizeModeEventHandler)(Events [AutoSizeRowsModeChangedEvent]);
3470 protected virtual void OnBackgroundColorChanged (EventArgs e)
3472 EventHandler eh = (EventHandler)(Events [BackgroundColorChangedEvent]);
3477 protected override void OnBindingContextChanged (EventArgs e)
3479 base.OnBindingContextChanged(e);
3483 protected virtual void OnBorderStyleChanged (EventArgs e)
3485 EventHandler eh = (EventHandler)(Events [BorderStyleChangedEvent]);
3490 protected virtual void OnCancelRowEdit (QuestionEventArgs e) {
3491 QuestionEventHandler eh = (QuestionEventHandler)(Events [CancelRowEditEvent]);
3496 protected virtual void OnCellBeginEdit (DataGridViewCellCancelEventArgs e)
3498 DataGridViewCellCancelEventHandler eh = (DataGridViewCellCancelEventHandler)(Events [CellBeginEditEvent]);
3503 protected virtual void OnCellBorderStyleChanged (EventArgs e)
3505 EventHandler eh = (EventHandler)(Events [CellBorderStyleChangedEvent]);
3510 protected virtual void OnCellClick (DataGridViewCellEventArgs e)
3512 DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3514 cell.OnClickInternal (e);
3516 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellClickEvent]);
3521 protected virtual void OnCellContentClick (DataGridViewCellEventArgs e)
3523 DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3525 cell.OnContentClickInternal (e);
3527 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellContentClickEvent]);
3532 protected virtual void OnCellContentDoubleClick (DataGridViewCellEventArgs e)
3534 DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3536 cell.OnContentDoubleClickInternal (e);
3538 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellContentDoubleClickEvent]);
3543 protected virtual void OnCellContextMenuStripChanged (DataGridViewCellEventArgs e)
3545 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellContextMenuStripChangedEvent]);
3550 protected virtual void OnCellContextMenuStripNeeded (DataGridViewCellContextMenuStripNeededEventArgs e)
3552 DataGridViewCellContextMenuStripNeededEventHandler eh = (DataGridViewCellContextMenuStripNeededEventHandler)(Events [CellContextMenuStripNeededEvent]);
3557 protected virtual void OnCellDoubleClick (DataGridViewCellEventArgs e)
3559 DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3561 cell.OnDoubleClickInternal (e);
3562 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellDoubleClickEvent]);
3567 protected virtual void OnCellEndEdit (DataGridViewCellEventArgs e)
3569 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellEndEditEvent]);
3574 protected virtual void OnCellEnter (DataGridViewCellEventArgs e)
3576 DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3577 cell.OnEnterInternal (e.RowIndex, true);
3579 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellEnterEvent]);
3584 protected internal virtual void OnCellErrorTextChanged (DataGridViewCellEventArgs e)
3586 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellErrorTextChangedEvent]);
3591 protected virtual void OnCellErrorTextNeeded (DataGridViewCellErrorTextNeededEventArgs e)
3593 DataGridViewCellErrorTextNeededEventHandler eh = (DataGridViewCellErrorTextNeededEventHandler)(Events [CellErrorTextNeededEvent]);
3598 internal void OnCellFormattingInternal (DataGridViewCellFormattingEventArgs e)
3600 OnCellFormatting (e);
3603 protected virtual void OnCellFormatting (DataGridViewCellFormattingEventArgs e)
3605 DataGridViewCellFormattingEventHandler eh = (DataGridViewCellFormattingEventHandler)(Events [CellFormattingEvent]);
3610 protected virtual void OnCellLeave (DataGridViewCellEventArgs e)
3612 DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3613 cell.OnLeaveInternal (e.RowIndex, true);
3615 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellLeaveEvent]);
3620 protected virtual void OnCellMouseClick (DataGridViewCellMouseEventArgs e)
3622 DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3624 cell.OnMouseClickInternal (e);
3626 DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [CellMouseClickEvent]);
3631 protected virtual void OnCellMouseDoubleClick (DataGridViewCellMouseEventArgs e)
3633 DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3635 cell.OnMouseDoubleClickInternal (e);
3637 DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [CellMouseDoubleClickEvent]);
3642 protected virtual void OnCellMouseDown (DataGridViewCellMouseEventArgs e)
3645 DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3647 cell.OnMouseDownInternal (e);
3649 DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [CellMouseDownEvent]);
3654 protected virtual void OnCellMouseEnter (DataGridViewCellEventArgs e)
3656 DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3658 cell.OnMouseEnterInternal (e.RowIndex);
3660 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellMouseEnterEvent]);
3665 protected virtual void OnCellMouseLeave (DataGridViewCellEventArgs e)
3667 DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3669 cell.OnMouseLeaveInternal (e.RowIndex);
3671 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellMouseLeaveEvent]);
3676 protected virtual void OnCellMouseMove (DataGridViewCellMouseEventArgs e)
3678 DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3680 cell.OnMouseMoveInternal (e);
3682 DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [CellMouseMoveEvent]);
3687 protected virtual void OnCellMouseUp (DataGridViewCellMouseEventArgs e)
3689 DataGridViewCell cell = GetCellInternal (e.ColumnIndex, e.RowIndex);
3691 cell.OnMouseUpInternal (e);
3693 DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [CellMouseUpEvent]);
3698 internal void OnCellPaintingInternal (DataGridViewCellPaintingEventArgs e)
3703 protected virtual void OnCellPainting (DataGridViewCellPaintingEventArgs e)
3705 DataGridViewCellPaintingEventHandler eh = (DataGridViewCellPaintingEventHandler)(Events [CellPaintingEvent]);
3710 protected internal virtual void OnCellParsing (DataGridViewCellParsingEventArgs e)
3712 DataGridViewCellParsingEventHandler eh = (DataGridViewCellParsingEventHandler)(Events [CellParsingEvent]);
3717 internal void OnCellStateChangedInternal (DataGridViewCellStateChangedEventArgs e) {
3718 this.OnCellStateChanged (e);
3721 protected virtual void OnCellStateChanged (DataGridViewCellStateChangedEventArgs e)
3723 DataGridViewCellStateChangedEventHandler eh = (DataGridViewCellStateChangedEventHandler)(Events [CellStateChangedEvent]);
3728 protected virtual void OnCellStyleChanged (DataGridViewCellEventArgs e)
3730 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellStyleChangedEvent]);
3735 protected virtual void OnCellStyleContentChanged (DataGridViewCellStyleContentChangedEventArgs e) {
3736 DataGridViewCellStyleContentChangedEventHandler eh = (DataGridViewCellStyleContentChangedEventHandler)(Events [CellStyleContentChangedEvent]);
3741 protected virtual void OnCellToolTipTextChanged (DataGridViewCellEventArgs e) {
3742 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellToolTipTextChangedEvent]);
3747 protected virtual void OnCellToolTipTextNeeded (DataGridViewCellToolTipTextNeededEventArgs e)
3749 DataGridViewCellToolTipTextNeededEventHandler eh = (DataGridViewCellToolTipTextNeededEventHandler)(Events [CellToolTipTextNeededEvent]);
3754 protected virtual void OnCellValidated (DataGridViewCellEventArgs e)
3756 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellValidatedEvent]);
3761 protected virtual void OnCellValidating (DataGridViewCellValidatingEventArgs e)
3763 DataGridViewCellValidatingEventHandler eh = (DataGridViewCellValidatingEventHandler)(Events [CellValidatingEvent]);
3768 protected virtual void OnCellValueChanged (DataGridViewCellEventArgs e)
3770 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [CellValueChangedEvent]);
3775 protected internal virtual void OnCellValueNeeded (DataGridViewCellValueEventArgs e)
3777 DataGridViewCellValueEventHandler eh = (DataGridViewCellValueEventHandler)(Events [CellValueNeededEvent]);
3782 protected virtual void OnCellValuePushed (DataGridViewCellValueEventArgs e)
3784 DataGridViewCellValueEventHandler eh = (DataGridViewCellValueEventHandler)(Events [CellValuePushedEvent]);
3789 internal void OnColumnAddedInternal (DataGridViewColumnEventArgs e)
3791 e.Column.DataColumnIndex = FindDataColumnIndex (e.Column);
3793 if (e.Column.CellTemplate != null) {
3794 // The first column has just been added programatically instead of
3795 // autogenerated so we need to create the rows for the first time.
3797 if (!is_autogenerating_columns && columns.Count == 1)
3800 // Add/Remove/Update the cells in the existing rows
3801 foreach (DataGridViewRow row in Rows) {
3802 if (row.Index == NewRowIndex)
3805 DataGridViewCell newCell = (DataGridViewCell)e.Column.CellTemplate.Clone ();
3806 if (row.Cells.Count == columns.Count) {
3807 DataGridViewCell oldCell = row.Cells[e.Column.Index];
3808 if (currentCell != null && oldCell == currentCell)
3809 currentCell = newCell;
3810 // copy the value only if the cell is not-databound
3811 if (!e.Column.IsDataBound && oldCell.OwningRow.DataBoundItem == null)
3812 newCell.Value = oldCell.Value;
3813 row.Cells.Replace (e.Column.Index, newCell);
3814 } else if (e.Column.Index >= row.Cells.Count)
3815 row.Cells.Add (newCell);
3817 row.Cells.Insert (e.Column.Index, newCell);
3821 AutoResizeColumnsInternal ();
3823 PrepareEditingRow (false, true);
3826 private int FindDataColumnIndex (DataGridViewColumn column)
3828 if (column != null && DataManager != null) {
3829 PropertyDescriptorCollection properties = DataManager.GetItemProperties();
3830 for (int i = 0; i < properties.Count; i++) {
3831 if (String.Compare (column.DataPropertyName, properties[i].Name, true) == 0)
3839 protected virtual void OnColumnAdded (DataGridViewColumnEventArgs e)
3841 DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnAddedEvent]);
3846 protected internal virtual void OnColumnContextMenuStripChanged (DataGridViewColumnEventArgs e)
3848 DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnContextMenuStripChangedEvent]);
3853 protected internal virtual void OnColumnDataPropertyNameChanged (DataGridViewColumnEventArgs e)
3855 DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnDataPropertyNameChangedEvent]);
3860 protected internal virtual void OnColumnDefaultCellStyleChanged (DataGridViewColumnEventArgs e)
3862 DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnDefaultCellStyleChangedEvent]);
3867 protected internal virtual void OnColumnDisplayIndexChanged (DataGridViewColumnEventArgs e)
3869 DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnDisplayIndexChangedEvent]);
3874 protected virtual void OnColumnDividerDoubleClick (DataGridViewColumnDividerDoubleClickEventArgs e)
3876 DataGridViewColumnDividerDoubleClickEventHandler eh = (DataGridViewColumnDividerDoubleClickEventHandler)(Events [ColumnDividerDoubleClickEvent]);
3881 protected internal virtual void OnColumnDividerWidthChanged (DataGridViewColumnEventArgs e)
3883 DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnDividerWidthChangedEvent]);
3888 protected internal virtual void OnColumnHeaderCellChanged (DataGridViewColumnEventArgs e)
3890 DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnHeaderCellChangedEvent]);
3895 protected virtual void OnColumnHeaderMouseClick (DataGridViewCellMouseEventArgs e)
3897 DataGridViewColumn col = Columns[e.ColumnIndex];
3899 if (col.SortMode == DataGridViewColumnSortMode.Automatic) {
3900 ListSortDirection new_order;
3902 // Always use ascending unless we are clicking on a
3903 // column that is already sorted ascending.
3904 if (SortedColumn != col || sortOrder != SortOrder.Ascending)
3905 new_order = ListSortDirection.Ascending;
3907 new_order = ListSortDirection.Descending;
3909 Sort (col, new_order);
3912 DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [ColumnHeaderMouseClickEvent]);
3917 protected virtual void OnColumnHeaderMouseDoubleClick (DataGridViewCellMouseEventArgs e)
3919 DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [ColumnHeaderMouseDoubleClickEvent]);
3924 protected virtual void OnColumnHeadersBorderStyleChanged (EventArgs e)
3926 EventHandler eh = (EventHandler)(Events [ColumnHeadersBorderStyleChangedEvent]);
3931 protected virtual void OnColumnHeadersDefaultCellStyleChanged (EventArgs e)
3933 EventHandler eh = (EventHandler)(Events [ColumnHeadersDefaultCellStyleChangedEvent]);
3938 protected virtual void OnColumnHeadersHeightChanged (EventArgs e)
3940 EventHandler eh = (EventHandler)(Events [ColumnHeadersHeightChangedEvent]);
3945 protected virtual void OnColumnHeadersHeightSizeModeChanged (DataGridViewAutoSizeModeEventArgs e)
3947 DataGridViewAutoSizeModeEventHandler eh = (DataGridViewAutoSizeModeEventHandler)(Events [ColumnHeadersHeightSizeModeChangedEvent]);
3952 protected internal virtual void OnColumnMinimumWidthChanged (DataGridViewColumnEventArgs e)
3954 DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnMinimumWidthChangedEvent]);
3959 protected internal virtual void OnColumnNameChanged (DataGridViewColumnEventArgs e)
3961 DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnNameChangedEvent]);
3966 internal void OnColumnPreRemovedInternal (DataGridViewColumnEventArgs e)
3968 if (Columns.Count - 1 == 0) {
3969 MoveCurrentCell (-1, -1, true, false, false, true);
3970 rows.ClearInternal ();
3971 } else if (currentCell != null && CurrentCell.ColumnIndex == e.Column.Index) {
3972 int nextColumnIndex = e.Column.Index;
3973 if (nextColumnIndex >= Columns.Count - 1)
3974 nextColumnIndex = Columns.Count - 1 - 1;
3975 MoveCurrentCell (nextColumnIndex, currentCell.RowIndex, true, false, false, true);
3976 if (hover_cell != null && hover_cell.ColumnIndex >= e.Column.Index)
3981 private void OnColumnPostRemovedInternal (DataGridViewColumnEventArgs e)
3983 if (e.Column.CellTemplate != null) {
3984 int index = e.Column.Index;
3986 foreach (DataGridViewRow row in Rows)
3987 row.Cells.RemoveAt (index);
3990 AutoResizeColumnsInternal ();
3991 PrepareEditingRow (false, true);
3993 OnColumnRemoved (e);
3996 protected virtual void OnColumnRemoved (DataGridViewColumnEventArgs e)
3998 DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnRemovedEvent]);
4003 protected internal virtual void OnColumnSortModeChanged (DataGridViewColumnEventArgs e)
4005 DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnSortModeChangedEvent]);
4010 protected internal virtual void OnColumnStateChanged (DataGridViewColumnStateChangedEventArgs e)
4012 DataGridViewColumnStateChangedEventHandler eh = (DataGridViewColumnStateChangedEventHandler)(Events [ColumnStateChangedEvent]);
4017 protected internal virtual void OnColumnToolTipTextChanged (DataGridViewColumnEventArgs e)
4019 DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnToolTipTextChangedEvent]);
4024 protected internal virtual void OnColumnWidthChanged (DataGridViewColumnEventArgs e)
4026 DataGridViewColumnEventHandler eh = (DataGridViewColumnEventHandler)(Events [ColumnWidthChangedEvent]);
4031 protected virtual void OnCurrentCellChanged (EventArgs e)
4033 EventHandler eh = (EventHandler)(Events [CurrentCellChangedEvent]);
4038 protected virtual void OnCurrentCellDirtyStateChanged (EventArgs e)
4040 EventHandler eh = (EventHandler)(Events [CurrentCellDirtyStateChangedEvent]);
4045 protected override void OnCursorChanged (EventArgs e)
4047 base.OnCursorChanged (e);
4050 protected virtual void OnDataBindingComplete (DataGridViewBindingCompleteEventArgs e)
4052 DataGridViewBindingCompleteEventHandler eh = (DataGridViewBindingCompleteEventHandler)(Events [DataBindingCompleteEvent]);
4057 protected virtual void OnDataError (bool displayErrorDialogIfNoHandler, DataGridViewDataErrorEventArgs e)
4059 DataGridViewDataErrorEventHandler eh = (DataGridViewDataErrorEventHandler)(Events [DataErrorEvent]);
4063 else if (displayErrorDialogIfNoHandler)
4064 MessageBox.Show (e.ToString ());
4066 protected virtual void OnDataMemberChanged (EventArgs e) {
4067 EventHandler eh = (EventHandler)(Events [DataMemberChangedEvent]);
4072 protected virtual void OnDataSourceChanged (EventArgs e) {
4073 EventHandler eh = (EventHandler)(Events [DataSourceChangedEvent]);
4078 protected virtual void OnDefaultCellStyleChanged (EventArgs e) {
4079 EventHandler eh = (EventHandler)(Events [DefaultCellStyleChangedEvent]);
4084 protected virtual void OnDefaultValuesNeeded (DataGridViewRowEventArgs e) {
4085 DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [DefaultValuesNeededEvent]);
4090 protected override void OnDoubleClick (EventArgs e) {
4091 base.OnDoubleClick(e);
4093 Point mouseLocation = this.PointToClient (Control.MousePosition);
4094 HitTestInfo hitInfo = HitTest (mouseLocation.X, mouseLocation.Y);
4095 if (hitInfo.Type == DataGridViewHitTestType.Cell)
4096 OnCellDoubleClick (new DataGridViewCellEventArgs (hitInfo.ColumnIndex, hitInfo.RowIndex));
4099 protected virtual void OnEditingControlShowing (DataGridViewEditingControlShowingEventArgs e) {
4100 DataGridViewEditingControlShowingEventHandler eh = (DataGridViewEditingControlShowingEventHandler)(Events [EditingControlShowingEvent]);
4105 protected virtual void OnEditModeChanged (EventArgs e)
4107 EventHandler eh = (EventHandler)(Events [EditModeChangedEvent]);
4112 protected override void OnEnabledChanged (EventArgs e)
4114 base.OnEnabledChanged(e);
4117 protected override void OnEnter (EventArgs e )
4122 protected override void OnGotFocus(EventArgs e)
4124 base.OnGotFocus (e);
4126 // To add focus rectangle if needed
4127 if (currentCell != null && ShowFocusCues)
4128 InvalidateCell (currentCell);
4131 protected override void OnFontChanged (EventArgs e)
4133 base.OnFontChanged(e);
4136 protected override void OnForeColorChanged (EventArgs e)
4138 base.OnForeColorChanged(e);
4141 protected virtual void OnGridColorChanged (EventArgs e)
4143 EventHandler eh = (EventHandler)(Events [GridColorChangedEvent]);
4148 protected override void OnHandleCreated (EventArgs e)
4150 base.OnHandleCreated(e);
4153 if (DataManager == null && CurrentCell == null && Rows.Count > 0 && Columns.Count > 0)
4154 MoveCurrentCell (ColumnDisplayIndexToIndex (0), 0, true, false, false, false);
4157 protected override void OnHandleDestroyed(EventArgs e)
4159 base.OnHandleDestroyed (e);
4162 [EditorBrowsable (EditorBrowsableState.Advanced)]
4163 protected override void OnKeyDown (KeyEventArgs e)
4167 e.Handled = ProcessDataGridViewKey (e);
4170 [EditorBrowsable (EditorBrowsableState.Advanced)]
4171 protected override void OnKeyPress (KeyPressEventArgs e)
4176 [EditorBrowsable (EditorBrowsableState.Advanced)]
4177 protected override void OnKeyUp (KeyEventArgs e)
4182 protected override void OnLayout (LayoutEventArgs e)
4184 if (horizontalScrollBar.Visible && verticalScrollBar.Visible) {
4185 horizontalScrollBar.Bounds = new Rectangle (BorderWidth, Height - BorderWidth - horizontalScrollBar.Height, Width - (2 * BorderWidth) - verticalScrollBar.Width, horizontalScrollBar.Height);
4186 verticalScrollBar.Bounds = new Rectangle (Width - BorderWidth - verticalScrollBar.Width, BorderWidth, verticalScrollBar.Width, Height - (2 * BorderWidth) - horizontalScrollBar.Height);
4187 } else if (horizontalScrollBar.Visible)
4188 horizontalScrollBar.Bounds = new Rectangle (BorderWidth, Height - BorderWidth - horizontalScrollBar.Height, Width - (2 * BorderWidth), horizontalScrollBar.Height);
4189 else if (verticalScrollBar.Visible)
4190 verticalScrollBar.Bounds = new Rectangle (Width - BorderWidth - verticalScrollBar.Width, BorderWidth, verticalScrollBar.Width, Height - (2 * BorderWidth));
4192 AutoResizeColumnsInternal ();
4196 protected override void OnLeave (EventArgs e)
4201 protected override void OnLostFocus(EventArgs e)
4203 base.OnLostFocus (e);
4205 // To remove focus rectangle if needed
4206 if (currentCell != null && ShowFocusCues)
4207 InvalidateCell (currentCell);
4210 protected override void OnMouseClick (MouseEventArgs e)
4212 base.OnMouseClick(e);
4214 if (column_resize_active || row_resize_active)
4217 //Console.WriteLine("Mouse: Clicks: {0}; Delta: {1}; X: {2}; Y: {3};", e.Clicks, e.Delta, e.X, e.Y);
4218 HitTestInfo hit = HitTest (e.X, e.Y);
4221 case DataGridViewHitTestType.Cell:
4222 Rectangle display = GetCellDisplayRectangle (hit.ColumnIndex, hit.RowIndex, false);
4223 Point cellpoint = new Point (e.X - display.X, e.Y - display.Y);
4225 OnCellMouseClick (new DataGridViewCellMouseEventArgs (hit.ColumnIndex, hit.RowIndex, cellpoint.X, cellpoint.Y, e));
4227 DataGridViewCell cell = GetCellInternal (hit.ColumnIndex, hit.RowIndex);
4229 if (cell.GetContentBounds (hit.RowIndex).Contains (cellpoint)) {
4230 DataGridViewCellEventArgs dgvcea = new DataGridViewCellEventArgs (hit.ColumnIndex, hit.RowIndex);
4231 OnCellContentClick (dgvcea);
4235 case DataGridViewHitTestType.ColumnHeader:
4236 Rectangle display2 = GetCellDisplayRectangle (hit.ColumnIndex, hit.RowIndex, false);
4237 Point cellpoint2 = new Point (e.X - display2.X, e.Y - display2.Y);
4239 OnColumnHeaderMouseClick (new DataGridViewCellMouseEventArgs (hit.ColumnIndex, hit.RowIndex, cellpoint2.X, cellpoint2.Y, e));
4244 protected override void OnMouseDoubleClick (MouseEventArgs e)
4246 base.OnMouseDoubleClick(e);
4248 HitTestInfo hitInfo = HitTest (e.X, e.Y);
4249 if (hitInfo.Type == DataGridViewHitTestType.Cell)
4250 OnCellMouseDoubleClick (new DataGridViewCellMouseEventArgs (hitInfo.ColumnIndex, hitInfo.RowIndex,
4251 hitInfo.ColumnX, hitInfo.RowY, e));
4254 private void DoSelectionOnMouseDown (HitTestInfo hitTest)
4256 Keys modifiers = Control.ModifierKeys;
4257 bool isControl = (modifiers & Keys.Control) != 0;
4258 bool isShift = (modifiers & Keys.Shift) != 0;
4259 //bool isRowHeader = hitTest.Type == DataGridViewHitTestType.RowHeader;
4260 //bool isColHeader = hitTest.Type == DataGridViewHitTestType.ColumnHeader;
4261 DataGridViewSelectionMode mode;
4263 switch (hitTest.Type) {
4264 case DataGridViewHitTestType.Cell:
4265 mode = selectionMode;
4267 case DataGridViewHitTestType.ColumnHeader:
4268 mode = selectionMode == DataGridViewSelectionMode.ColumnHeaderSelect ? DataGridViewSelectionMode.FullColumnSelect : selectionMode;
4270 if (mode != DataGridViewSelectionMode.FullColumnSelect)
4273 case DataGridViewHitTestType.RowHeader:
4274 mode = selectionMode == DataGridViewSelectionMode.RowHeaderSelect ? DataGridViewSelectionMode.FullRowSelect : selectionMode;
4276 if (mode != DataGridViewSelectionMode.FullRowSelect)
4278 break; // Handled below
4284 // If SHIFT is pressed:
4285 // Select all from selected_row/column/cell to current row/column/cell, unselect everything else
4287 // Unselect all rows/columns/cells, select the clicked one
4288 int min_row, max_row;
4289 int min_col, max_col;
4291 selected_row = hitTest.RowIndex;
4292 selected_column = hitTest.ColumnIndex;
4295 if (selected_row != -1)
4296 selected_row = hitTest.RowIndex;
4297 if (selected_column != -1)
4298 selected_column = hitTest.ColumnIndex;
4300 if (selected_row >= hitTest.RowIndex) {
4301 min_row = hitTest.RowIndex;
4302 max_row = isShift ? selected_row : min_row;
4304 max_row = hitTest.RowIndex;
4305 min_row = isShift ? selected_row : max_row;
4307 if (selected_column >= hitTest.ColumnIndex) {
4308 min_col = hitTest.ColumnIndex;
4309 max_col = isShift ? selected_column : min_col;
4311 max_col = hitTest.ColumnIndex;
4312 min_col = isShift ? selected_column : max_col;
4316 case DataGridViewSelectionMode.FullRowSelect:
4317 for (int i = 0; i < RowCount; i++) {
4318 bool select = i >= min_row && i <= max_row;
4320 for (int c = 0; c < ColumnCount; c++) {
4321 if (Rows [i].Cells [c].Selected) {
4322 SetSelectedCellCore (c, i, false);
4326 if (select != Rows [i].Selected) {
4327 SetSelectedRowCore (i, select);
4331 case DataGridViewSelectionMode.FullColumnSelect:
4332 for (int i = 0; i < ColumnCount; i++) {
4333 bool select = i >= min_col && i <= max_col;
4335 for (int r = 0; r < RowCount; r++) {
4336 if (Rows [r].Cells [i].Selected) {
4337 SetSelectedCellCore (i, r, false);
4341 if (select != Columns [i].Selected) {
4342 SetSelectedColumnCore (i, select);
4346 case DataGridViewSelectionMode.ColumnHeaderSelect:
4347 case DataGridViewSelectionMode.RowHeaderSelect:
4349 case DataGridViewSelectionMode.CellSelect:
4351 for (int c = 0; c < ColumnCount; c++) {
4352 if (columns [c].Selected)
4353 SetSelectedColumnCore (c, false);
4356 for (int r = 0; r < RowCount; r++) {
4357 if (rows [r].Selected)
4358 SetSelectedRowCore (r, false);
4361 for (int r = 0; r < RowCount; r++) {
4362 for (int c = 0; c < ColumnCount; c++) {
4363 bool select = (r >= min_row && r <= max_row) && (c >= min_col && c <= max_col);
4364 if (select != Rows [r].Cells [c].Selected)
4365 SetSelectedCellCore (c, r, select);
4371 } else if (isControl) {
4372 // Switch the selected state of the row.
4374 case DataGridViewSelectionMode.FullRowSelect:
4375 SetSelectedRowCore (hitTest.RowIndex, !rows [hitTest.RowIndex].Selected);
4377 case DataGridViewSelectionMode.FullColumnSelect:
4378 SetSelectedColumnCore (hitTest.ColumnIndex, !columns [hitTest.ColumnIndex].Selected);
4380 case DataGridViewSelectionMode.ColumnHeaderSelect:
4381 case DataGridViewSelectionMode.RowHeaderSelect:
4383 case DataGridViewSelectionMode.CellSelect:
4384 if (hitTest.ColumnIndex >= 0 && hitTest.RowIndex >= 0) {
4385 SetSelectedCellCore (hitTest.ColumnIndex, hitTest.RowIndex, !Rows [hitTest.RowIndex].Cells [hitTest.ColumnIndex].Selected);
4393 protected override void OnMouseDown (MouseEventArgs e)
4395 base.OnMouseDown(e);
4400 HitTestInfo hitTest = HitTest(e.X, e.Y);
4402 DataGridViewCell cell = null;
4403 DataGridViewRow row = null;
4404 Rectangle cellBounds;
4406 if ((hitTest.Type == DataGridViewHitTestType.ColumnHeader ||
4407 (hitTest.Type == DataGridViewHitTestType.Cell && !ColumnHeadersVisible))
4408 && MouseOverColumnResize (hitTest.ColumnIndex, e.X)) {
4409 if (e.Clicks == 2) {
4410 AutoResizeColumn (hitTest.ColumnIndex);
4414 resize_band = hitTest.ColumnIndex;
4415 column_resize_active = true;
4416 resize_band_start = e.X;
4417 resize_band_delta = 0;
4418 DrawVerticalResizeLine (resize_band_start);
4422 if (hitTest.Type == DataGridViewHitTestType.RowHeader && MouseOverRowResize (hitTest.RowIndex, e.Y)) {
4423 if (e.Clicks == 2) {
4424 AutoResizeRow (hitTest.RowIndex);
4428 resize_band = hitTest.RowIndex;
4429 row_resize_active = true;
4430 resize_band_start = e.Y;
4431 resize_band_delta = 0;
4432 DrawHorizontalResizeLine (resize_band_start);
4436 if (hitTest.Type == DataGridViewHitTestType.Cell) {
4437 row = rows [hitTest.RowIndex];
4438 cell = row.Cells [hitTest.ColumnIndex];
4439 SetCurrentCellAddressCore (cell.ColumnIndex, cell.RowIndex, false, true, true);
4440 cellBounds = GetCellDisplayRectangle (hitTest.ColumnIndex, hitTest.RowIndex, false);
4441 OnCellMouseDown (new DataGridViewCellMouseEventArgs (hitTest.ColumnIndex, hitTest.RowIndex, e.X - cellBounds.X, e.Y - cellBounds.Y, e));
4442 OnCellClick (new DataGridViewCellEventArgs (hitTest.ColumnIndex, hitTest.RowIndex));
4445 DoSelectionOnMouseDown (hitTest);
4447 if (hitTest.Type != DataGridViewHitTestType.Cell) {
4448 if (hitTest.Type == DataGridViewHitTestType.ColumnHeader)
4449 pressed_header_cell = columns [hitTest.ColumnIndex].HeaderCell;
4450 else if (hitTest.Type == DataGridViewHitTestType.RowHeader)
4451 pressed_header_cell = rows [hitTest.RowIndex].HeaderCell;
4460 private void UpdateBindingPosition (int position)
4462 if (DataManager != null)
4463 DataManager.Position = position;
4466 protected override void OnMouseEnter (EventArgs e)
4468 base.OnMouseEnter(e);
4471 protected override void OnMouseLeave (EventArgs e)
4473 base.OnMouseLeave (e);
4475 if (hover_cell != null) {
4476 OnCellMouseLeave (new DataGridViewCellEventArgs (hover_cell.ColumnIndex, hover_cell.RowIndex));
4480 EnteredHeaderCell = null;
4483 protected override void OnMouseMove (MouseEventArgs e)
4485 base.OnMouseMove (e);
4487 if (column_resize_active) {
4488 // Erase the old line
4489 DrawVerticalResizeLine (resize_band_start + resize_band_delta);
4491 resize_band_delta = e.X - resize_band_start;
4493 // Draw the new line
4494 DrawVerticalResizeLine (resize_band_start + resize_band_delta);
4498 if (row_resize_active) {
4499 // Erase the old line
4500 DrawHorizontalResizeLine (resize_band_start + resize_band_delta);
4502 resize_band_delta = e.Y - resize_band_start;
4504 // Draw the new line
4505 DrawHorizontalResizeLine (resize_band_start + resize_band_delta);
4509 Cursor new_cursor = Cursors.Default;
4510 HitTestInfo hit = this.HitTest (e.X, e.Y);
4512 if (hit.Type == DataGridViewHitTestType.ColumnHeader ||
4513 (!ColumnHeadersVisible && hit.Type == DataGridViewHitTestType.Cell && MouseOverColumnResize (hit.ColumnIndex, e.X))) {
4514 EnteredHeaderCell = Columns [hit.ColumnIndex].HeaderCell;
4515 if (MouseOverColumnResize (hit.ColumnIndex, e.X))
4516 new_cursor = Cursors.VSplit;
4517 } else if (hit.Type == DataGridViewHitTestType.Cell) {
4518 EnteredHeaderCell = null;
4520 DataGridViewCell new_cell = GetCellInternal (hit.ColumnIndex, hit.RowIndex);
4522 // Check if we have moved into an error icon area
4523 Rectangle icon = new_cell.ErrorIconBounds;
4525 if (!icon.IsEmpty) {
4526 Point loc = GetCellDisplayRectangle (hit.ColumnIndex, hit.RowIndex, false).Location;
4531 if (icon.Contains (e.X, e.Y)) {
4532 if (tooltip_currently_showing != new_cell)
4533 MouseEnteredErrorIcon (new_cell);
4535 MouseLeftErrorIcon (new_cell);
4538 Cursor = new_cursor;
4540 // We have never been in a cell before
4541 if (hover_cell == null) {
4542 hover_cell = new_cell;
4543 OnCellMouseEnter (new DataGridViewCellEventArgs (hit.ColumnIndex, hit.RowIndex));
4545 Rectangle display = GetCellDisplayRectangle (hit.ColumnIndex, hit.RowIndex, false);
4546 OnCellMouseMove (new DataGridViewCellMouseEventArgs (hit.ColumnIndex, hit.RowIndex, e.X - display.X, e.Y - display.Y, e));
4551 // Were we already in this cell?
4552 if (hover_cell.RowIndex == hit.RowIndex && hover_cell.ColumnIndex == hit.ColumnIndex) {
4553 Rectangle display = GetCellDisplayRectangle (hit.ColumnIndex, hit.RowIndex, false);
4554 OnCellMouseMove (new DataGridViewCellMouseEventArgs (hit.ColumnIndex, hit.RowIndex, e.X - display.X, e.Y - display.Y, e));
4559 // We are changing cells
4560 OnCellMouseLeave (new DataGridViewCellEventArgs (hover_cell.ColumnIndex, hover_cell.RowIndex));
4562 hover_cell = new_cell;
4564 OnCellMouseEnter (new DataGridViewCellEventArgs (hit.ColumnIndex, hit.RowIndex));
4566 Rectangle display2 = GetCellDisplayRectangle (hit.ColumnIndex, hit.RowIndex, false);
4567 OnCellMouseMove (new DataGridViewCellMouseEventArgs (hit.ColumnIndex, hit.RowIndex, e.X - display2.X, e.Y - display2.Y, e));
4570 } else if (hit.Type == DataGridViewHitTestType.RowHeader) {
4571 DataGridViewRowHeaderCell new_cell = Rows[hit.RowIndex].HeaderCell;
4573 EnteredHeaderCell = new_cell;
4575 if (MouseOverRowResize (hit.RowIndex, e.Y))
4576 new_cursor = Cursors.HSplit;
4578 // Check if we have moved into an error icon area
4579 Rectangle icon = new_cell.InternalErrorIconsBounds;
4581 if (!icon.IsEmpty) {
4582 Point loc = GetCellDisplayRectangle (0, hit.RowIndex, false).Location;
4584 icon.X += BorderWidth;
4587 if (icon.Contains (e.X, e.Y)) {
4588 if (tooltip_currently_showing != new_cell)
4589 MouseEnteredErrorIcon (new_cell);
4591 MouseLeftErrorIcon (new_cell);
4593 } else if (hit.Type == DataGridViewHitTestType.TopLeftHeader) {
4594 EnteredHeaderCell = null;
4596 DataGridViewTopLeftHeaderCell new_cell = (DataGridViewTopLeftHeaderCell)TopLeftHeaderCell;
4598 // Check if we have moved into an error icon area
4599 Rectangle icon = new_cell.InternalErrorIconsBounds;
4601 if (!icon.IsEmpty) {
4602 Point loc = Point.Empty;
4604 icon.X += BorderWidth;
4607 if (icon.Contains (e.X, e.Y)) {
4608 if (tooltip_currently_showing != new_cell)
4609 MouseEnteredErrorIcon (new_cell);
4611 MouseLeftErrorIcon (new_cell);
4615 EnteredHeaderCell = null;
4617 // We have left the cell area
4618 if (hover_cell != null) {
4619 OnCellMouseLeave (new DataGridViewCellEventArgs (hover_cell.ColumnIndex, hover_cell.RowIndex));
4624 Cursor = new_cursor;
4627 protected override void OnMouseUp (MouseEventArgs e)
4631 if (column_resize_active) {
4632 column_resize_active = false;
4634 if (resize_band_delta + Columns[resize_band].Width < 0)
4635 resize_band_delta = -Columns[resize_band].Width;
4637 Columns[resize_band].Width = Math.Max (resize_band_delta + Columns[resize_band].Width, Columns[resize_band].MinimumWidth);
4642 if (row_resize_active) {
4643 row_resize_active = false;
4645 if (resize_band_delta + Rows[resize_band].Height < 0)
4646 resize_band_delta = -Rows[resize_band].Height;
4648 Rows[resize_band].Height = Math.Max (resize_band_delta + Rows[resize_band].Height, Rows[resize_band].MinimumHeight);
4653 HitTestInfo hit = this.HitTest (e.X, e.Y);
4655 if (hit.Type == DataGridViewHitTestType.Cell) {
4656 Rectangle display = GetCellDisplayRectangle (hit.ColumnIndex, hit.RowIndex, false);
4657 OnCellMouseUp (new DataGridViewCellMouseEventArgs (hit.ColumnIndex, hit.RowIndex, e.X - display.X, e.Y - display.Y, e));
4660 if (pressed_header_cell != null) {
4661 DataGridViewHeaderCell cell = pressed_header_cell;
4662 pressed_header_cell = null;
4663 if (ThemeEngine.Current.DataGridViewHeaderCellHasPressedStyle (this))
4664 Invalidate (GetHeaderCellBounds (cell));
4668 protected override void OnMouseWheel (MouseEventArgs e)
4670 base.OnMouseWheel(e);
4672 int delta = SystemInformation.MouseWheelScrollLines * verticalScrollBar.SmallChange;
4674 verticalScrollBar.SafeValueSet (verticalScrollBar.Value + delta);
4676 verticalScrollBar.SafeValueSet (verticalScrollBar.Value - delta);
4678 OnVScrollBarScroll (this, new ScrollEventArgs (ScrollEventType.ThumbPosition, verticalScrollBar.Value));
4681 protected virtual void OnMultiSelectChanged (EventArgs e)
4683 EventHandler eh = (EventHandler)(Events [MultiSelectChangedEvent]);
4684 if (eh != null) eh (this, e);
4687 protected virtual void OnNewRowNeeded (DataGridViewRowEventArgs e) {
4688 DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [NewRowNeededEvent]);
4689 if (eh != null) eh (this, e);
4692 int first_row_index = 0;
4693 internal int first_col_index = 0;
4695 protected override void OnPaint (PaintEventArgs e)
4697 Graphics g = e.Graphics;
4698 Rectangle bounds = ClientRectangle;
4700 // Paint the background
4701 PaintBackground (g, e.ClipRectangle, bounds);
4703 List<DataGridViewColumn> sortedColumns = columns.ColumnDisplayIndexSortedArrayList;
4705 // Take borders into account
4706 bounds.Inflate (-BorderWidth, -BorderWidth);
4708 // Paint the top left cell
4709 if (rowHeadersVisible && columnHeadersVisible && ColumnCount > 0) {
4710 Rectangle topleftbounds = new Rectangle (bounds.X, bounds.Y, rowHeadersWidth, columnHeadersHeight);
4712 TopLeftHeaderCell.PaintWork (g, e.ClipRectangle, topleftbounds, -1, TopLeftHeaderCell.State, ColumnHeadersDefaultCellStyle, AdvancedColumnHeadersBorderStyle, DataGridViewPaintParts.All);
4715 // Paint the column headers
4716 if (columnHeadersVisible) {
4717 Rectangle headerBounds = bounds;
4718 headerBounds.Height = columnHeadersHeight;
4720 if (rowHeadersVisible)
4721 headerBounds.X += rowHeadersWidth;
4723 for (int index = first_col_index; index < sortedColumns.Count; index++) {
4724 DataGridViewColumn col = sortedColumns[index];
4729 headerBounds.Width = col.Width;
4730 DataGridViewCell cell = col.HeaderCell;
4732 DataGridViewAdvancedBorderStyle intermediateBorderStyle = (DataGridViewAdvancedBorderStyle)((ICloneable)this.AdvancedColumnHeadersBorderStyle).Clone ();
4733 DataGridViewAdvancedBorderStyle borderStyle = AdjustColumnHeaderBorderStyle (this.AdvancedColumnHeadersBorderStyle, intermediateBorderStyle, cell.ColumnIndex == 0, cell.ColumnIndex == columns.Count - 1);
4735 cell.PaintWork (g, e.ClipRectangle, headerBounds, -1, cell.State, cell.InheritedStyle, borderStyle, DataGridViewPaintParts.All);
4737 headerBounds.X += col.Width;
4740 bounds.Y += columnHeadersHeight;
4743 // Reset not displayed columns to !Displayed
4744 for (int i = 0; i < first_col_index; i++)
4745 Columns[i].DisplayedInternal = false;
4747 int gridWidth = rowHeadersVisible ? rowHeadersWidth : 0;
4749 // Set Displayed columns
4750 for (int i = first_col_index; i < Columns.Count; i++) {
4751 DataGridViewColumn col = Columns.ColumnDisplayIndexSortedArrayList[i];
4756 col.DisplayedInternal = true;
4757 gridWidth += col.Width;
4758 if (gridWidth >= Width)
4762 // Reset all not displayed rows to !Displayed
4763 for (int i = 0; i < first_row_index; i++)
4764 GetRowInternal (i).DisplayedInternal = false;
4767 for (int index = first_row_index; index < Rows.Count; index++) {
4768 DataGridViewRow row = Rows[index];
4771 GetRowInternal (index).DisplayedInternal = true;
4773 bounds.Height = row.Height;
4774 bool is_first = row.Index == 0;
4775 bool is_last = row.Index == rows.Count - 1;
4777 row.Paint (g, e.ClipRectangle, bounds, row.Index, row.GetState (row.Index), is_first, is_last);
4779 bounds.Y += bounds.Height;
4780 bounds.X = BorderWidth;
4782 if (bounds.Y >= ClientSize.Height - (horizontalScrollBar.Visible ? horizontalScrollBar.Height : 0))
4786 RefreshScrollBars ();
4788 // Paint the bottom right square if both scrollbars are displayed
4789 if (horizontalScrollBar.Visible && verticalScrollBar.Visible)
4790 g.FillRectangle (SystemBrushes.Control, new Rectangle (horizontalScrollBar.Right, verticalScrollBar.Bottom, verticalScrollBar.Width, horizontalScrollBar.Height));
4793 bounds = ClientRectangle;
4795 switch (BorderStyle) {
4796 case BorderStyle.FixedSingle:
4797 g.DrawRectangle (Pens.Black, new Rectangle (bounds.Left, bounds.Top, bounds.Width - 1, bounds.Height - 1));
4799 case BorderStyle.Fixed3D:
4800 ControlPaint.DrawBorder3D (g, bounds, Border3DStyle.Sunken);
4804 // Call the base impl at the end.
4808 private void RefreshScrollBars ()
4813 foreach (DataGridViewColumn col in columns.ColumnDisplayIndexSortedArrayList)
4815 gridWidth += col.Width;
4817 foreach (DataGridViewRow row in Rows)
4819 gridHeight += row.Height;
4821 if (rowHeadersVisible)
4822 gridWidth += rowHeadersWidth;
4823 if (columnHeadersVisible)
4824 gridHeight += columnHeadersHeight;
4826 bool horizontalVisible = false;
4827 bool verticalVisible = false;
4830 if (gridWidth > Size.Width || gridHeight > Size.Height)
4831 Size = new Size(gridWidth, gridHeight);
4834 if (gridWidth > Size.Width)
4835 horizontalVisible = true;
4836 if (gridHeight > Size.Height)
4837 verticalVisible = true;
4839 if (horizontalScrollBar.Visible && (gridHeight + horizontalScrollBar.Height) > Size.Height)
4840 verticalVisible = true;
4841 if (verticalScrollBar.Visible && (gridWidth + verticalScrollBar.Width) > Size.Width)
4842 horizontalVisible = true;
4844 if (scrollBars != ScrollBars.Vertical && scrollBars != ScrollBars.Both)
4845 verticalVisible = false;
4846 if (scrollBars != ScrollBars.Horizontal && scrollBars != ScrollBars.Both)
4847 horizontalVisible = false;
4849 // MSNET compatibility here
4851 verticalVisible = false;
4853 if (horizontalVisible) {
4854 horizontalScrollBar.Minimum = 0;
4855 horizontalScrollBar.Maximum = gridWidth;
4856 horizontalScrollBar.SmallChange = Columns[first_col_index].Width;
4857 int largeChange = ClientSize.Width - rowHeadersWidth - horizontalScrollBar.Height;
4858 if (largeChange <= 0)
4859 largeChange = ClientSize.Width;
4860 horizontalScrollBar.LargeChange = largeChange;
4863 if (verticalVisible) {
4864 verticalScrollBar.Minimum = 0;
4865 verticalScrollBar.Maximum = gridHeight;
4866 int first_row_height = Rows.Count > 0 ? Rows[Math.Min (Rows.Count - 1, first_row_index)].Height : 0;
4867 verticalScrollBar.SmallChange = first_row_height + 1;
4868 int largeChange = ClientSize.Height - columnHeadersHeight - verticalScrollBar.Width;
4869 if (largeChange <= 0)
4870 largeChange = ClientSize.Height;
4871 verticalScrollBar.LargeChange = largeChange;
4875 horizontalScrollBar.Visible = horizontalVisible;
4876 verticalScrollBar.Visible = verticalVisible;
4879 protected virtual void OnReadOnlyChanged (EventArgs e) {
4880 EventHandler eh = (EventHandler)(Events [ReadOnlyChangedEvent]);
4885 protected override void OnResize (EventArgs e) {
4887 AutoResizeColumnsInternal ();
4889 OnVScrollBarScroll (this, new ScrollEventArgs (ScrollEventType.ThumbPosition, verticalScrollBar.Value));
4890 OnHScrollBarScroll (this, new ScrollEventArgs (ScrollEventType.ThumbPosition, horizontalScrollBar.Value));
4893 protected override void OnRightToLeftChanged (EventArgs e) {
4894 base.OnRightToLeftChanged(e);
4897 // In MSDN2 documentation there's no internal here
4898 protected internal virtual void OnRowContextMenuStripChanged (DataGridViewRowEventArgs e)
4900 DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowContextMenuStripChangedEvent]);
4901 if (eh != null) eh (this, e);
4904 protected virtual void OnRowContextMenuStripNeeded (DataGridViewRowContextMenuStripNeededEventArgs e)
4906 DataGridViewRowContextMenuStripNeededEventHandler eh = (DataGridViewRowContextMenuStripNeededEventHandler)(Events [RowContextMenuStripNeededEvent]);
4907 if (eh != null) eh (this, e);
4910 protected internal virtual void OnRowDefaultCellStyleChanged (DataGridViewRowEventArgs e)
4912 DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowDefaultCellStyleChangedEvent]);
4913 if (eh != null) eh (this, e);
4916 protected virtual void OnRowDirtyStateNeeded (QuestionEventArgs e)
4918 QuestionEventHandler eh = (QuestionEventHandler)(Events [RowDirtyStateNeededEvent]);
4919 if (eh != null) eh (this, e);
4922 protected virtual void OnRowDividerDoubleClick (DataGridViewRowDividerDoubleClickEventArgs e)
4924 DataGridViewRowDividerDoubleClickEventHandler eh = (DataGridViewRowDividerDoubleClickEventHandler)(Events [RowDividerDoubleClickEvent]);
4925 if (eh != null) eh (this, e);
4928 protected virtual void OnRowDividerHeightChanged (DataGridViewRowEventArgs e)
4930 DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowDividerHeightChangedEvent]);
4931 if (eh != null) eh (this, e);
4934 protected virtual void OnRowEnter (DataGridViewCellEventArgs e)
4936 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [RowEnterEvent]);
4937 if (eh != null) eh (this, e);
4940 protected internal virtual void OnRowErrorTextChanged (DataGridViewRowEventArgs e)
4942 DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowErrorTextChangedEvent]);
4943 if (eh != null) eh (this, e);
4946 protected virtual void OnRowErrorTextNeeded (DataGridViewRowErrorTextNeededEventArgs e)
4948 DataGridViewRowErrorTextNeededEventHandler eh = (DataGridViewRowErrorTextNeededEventHandler)(Events [RowErrorTextNeededEvent]);
4949 if (eh != null) eh (this, e);
4952 protected internal virtual void OnRowHeaderCellChanged (DataGridViewRowEventArgs e)
4954 DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowHeaderCellChangedEvent]);
4955 if (eh != null) eh (this, e);
4958 protected virtual void OnRowHeaderMouseClick (DataGridViewCellMouseEventArgs e)
4960 DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [RowHeaderMouseClickEvent]);
4961 if (eh != null) eh (this, e);
4964 protected virtual void OnRowHeaderMouseDoubleClick (DataGridViewCellMouseEventArgs e)
4966 DataGridViewCellMouseEventHandler eh = (DataGridViewCellMouseEventHandler)(Events [RowHeaderMouseDoubleClickEvent]);
4967 if (eh != null) eh (this, e);
4970 protected virtual void OnRowHeadersBorderStyleChanged (EventArgs e)
4972 EventHandler eh = (EventHandler)(Events [RowHeadersBorderStyleChangedEvent]);
4973 if (eh != null) eh (this, e);
4976 protected virtual void OnRowHeadersDefaultCellStyleChanged (EventArgs e)
4978 EventHandler eh = (EventHandler)(Events [RowHeadersDefaultCellStyleChangedEvent]);
4979 if (eh != null) eh (this, e);
4982 protected virtual void OnRowHeadersWidthChanged (EventArgs e)
4984 EventHandler eh = (EventHandler)(Events [RowHeadersWidthChangedEvent]);
4985 if (eh != null) eh (this, e);
4988 protected virtual void OnRowHeadersWidthSizeModeChanged (DataGridViewAutoSizeModeEventArgs e)
4990 DataGridViewAutoSizeModeEventHandler eh = (DataGridViewAutoSizeModeEventHandler)(Events [RowHeadersWidthSizeModeChangedEvent]);
4991 if (eh != null) eh (this, e);
4994 protected internal virtual void OnRowHeightChanged (DataGridViewRowEventArgs e)
4996 UpdateRowHeightInfo (e.Row.Index, false);
4997 DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowHeightChangedEvent]);
4998 if (eh != null) eh (this, e);
5001 protected virtual void OnRowHeightInfoNeeded (DataGridViewRowHeightInfoNeededEventArgs e)
5003 DataGridViewRowHeightInfoNeededEventHandler eh = (DataGridViewRowHeightInfoNeededEventHandler)(Events [RowHeightInfoNeededEvent]);
5004 if (eh != null) eh (this, e);
5007 protected virtual void OnRowHeightInfoPushed (DataGridViewRowHeightInfoPushedEventArgs e)
5009 DataGridViewRowHeightInfoPushedEventHandler eh = (DataGridViewRowHeightInfoPushedEventHandler)(Events [RowHeightInfoPushedEvent]);
5010 if (eh != null) eh (this, e);
5013 protected virtual void OnRowLeave (DataGridViewCellEventArgs e)
5015 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [RowLeaveEvent]);
5016 if (eh != null) eh (this, e);
5019 protected internal virtual void OnRowMinimumHeightChanged (DataGridViewRowEventArgs e)
5021 DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowMinimumHeightChangedEvent]);
5022 if (eh != null) eh (this, e);
5025 protected internal virtual void OnRowPostPaint (DataGridViewRowPostPaintEventArgs e)
5027 DataGridViewRowPostPaintEventHandler eh = (DataGridViewRowPostPaintEventHandler)(Events [RowPostPaintEvent]);
5028 if (eh != null) eh (this, e);
5031 protected internal virtual void OnRowPrePaint (DataGridViewRowPrePaintEventArgs e)
5033 DataGridViewRowPrePaintEventHandler eh = (DataGridViewRowPrePaintEventHandler)(Events [RowPrePaintEvent]);
5034 if (eh != null) eh (this, e);
5037 internal void OnRowsAddedInternal (DataGridViewRowsAddedEventArgs e)
5039 if (hover_cell != null && hover_cell.RowIndex >= e.RowIndex)
5042 // Select the first row if we are not databound.
5043 // If we are databound selection is managed by the data manager.
5044 if (IsHandleCreated && DataManager == null && CurrentCell == null && Rows.Count > 0 && Columns.Count > 0)
5045 MoveCurrentCell (ColumnDisplayIndexToIndex (0), 0, true, false, false, true);
5047 AutoResizeColumnsInternal ();
5052 protected virtual void OnRowsAdded (DataGridViewRowsAddedEventArgs e)
5054 DataGridViewRowsAddedEventHandler eh = (DataGridViewRowsAddedEventHandler)(Events [RowsAddedEvent]);
5055 if (eh != null) eh (this, e);
5058 protected virtual void OnRowsDefaultCellStyleChanged (EventArgs e)
5060 EventHandler eh = (EventHandler)(Events [RowsDefaultCellStyleChangedEvent]);
5061 if (eh != null) eh (this, e);
5064 internal void OnRowsPreRemovedInternal (DataGridViewRowsRemovedEventArgs e)
5066 if (selected_rows != null)
5067 selected_rows.InternalClear ();
5068 if (selected_columns != null)
5069 selected_columns.InternalClear ();
5071 if (Rows.Count - e.RowCount <= 0) {
5072 MoveCurrentCell (-1, -1, true, false, false, true);
5074 } else if (Columns.Count == 0) {
5075 MoveCurrentCell (-1, -1, true, false, false, true);
5077 } else if (currentCell != null && currentCell.RowIndex == e.RowIndex) {
5078 int nextRowIndex = e.RowIndex;
5079 if (nextRowIndex >= Rows.Count - e.RowCount)
5080 nextRowIndex = Rows.Count - 1 - e.RowCount;
5081 MoveCurrentCell (currentCell != null ? currentCell.ColumnIndex : 0, nextRowIndex,
5082 true, false, false, true);
5083 if (hover_cell != null && hover_cell.RowIndex >= e.RowIndex)
5088 internal void OnRowsPostRemovedInternal (DataGridViewRowsRemovedEventArgs e)
5094 protected virtual void OnRowsRemoved (DataGridViewRowsRemovedEventArgs e)
5096 DataGridViewRowsRemovedEventHandler eh = (DataGridViewRowsRemovedEventHandler)(Events [RowsRemovedEvent]);
5097 if (eh != null) eh (this, e);
5100 protected internal virtual void OnRowStateChanged (int rowIndex, DataGridViewRowStateChangedEventArgs e)
5102 DataGridViewRowStateChangedEventHandler eh = (DataGridViewRowStateChangedEventHandler)(Events [RowStateChangedEvent]);
5103 if (eh != null) eh (this, e);
5106 protected virtual void OnRowUnshared (DataGridViewRowEventArgs e)
5108 DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [RowUnsharedEvent]);
5109 if (eh != null) eh (this, e);
5112 protected virtual void OnRowValidated (DataGridViewCellEventArgs e)
5114 DataGridViewCellEventHandler eh = (DataGridViewCellEventHandler)(Events [RowValidatedEvent]);
5115 if (eh != null) eh (this, e);
5118 protected virtual void OnRowValidating (DataGridViewCellCancelEventArgs e)
5120 DataGridViewCellCancelEventHandler eh = (DataGridViewCellCancelEventHandler)(Events [RowValidatingEvent]);
5121 if (eh != null) eh (this, e);
5124 protected virtual void OnScroll (ScrollEventArgs e)
5126 ScrollEventHandler eh = (ScrollEventHandler)(Events [ScrollEvent]);
5127 if (eh != null) eh (this, e);
5130 protected virtual void OnSelectionChanged (EventArgs e)
5132 EventHandler eh = (EventHandler)(Events [SelectionChangedEvent]);
5133 if (eh != null) eh (this, e);
5136 protected virtual void OnSortCompare (DataGridViewSortCompareEventArgs e) {
5137 DataGridViewSortCompareEventHandler eh = (DataGridViewSortCompareEventHandler)(Events [SortCompareEvent]);
5138 if (eh != null) eh (this, e);
5141 protected virtual void OnSorted (EventArgs e)
5143 EventHandler eh = (EventHandler)(Events [SortedEvent]);
5144 if (eh != null) eh (this, e);
5147 protected virtual void OnUserAddedRow (DataGridViewRowEventArgs e)
5149 PrepareEditingRow (false, false);
5151 new_row_editing = true;
5152 if (DataManager != null) {
5153 // Switch the current editing row with a real one
5154 if (editing_row != null) {
5155 Rows.RemoveInternal (editing_row);
5158 DataManager.AddNew (); // will raise OnListPositionChanged
5161 e = new DataGridViewRowEventArgs (Rows[NewRowIndex]);
5162 DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [UserAddedRowEvent]);
5163 if (eh != null) eh (this, e);
5166 protected virtual void OnUserDeletedRow (DataGridViewRowEventArgs e)
5168 DataGridViewRowEventHandler eh = (DataGridViewRowEventHandler)(Events [UserDeletedRowEvent]);
5169 if (eh != null) eh (this, e);
5172 protected virtual void OnUserDeletingRow (DataGridViewRowCancelEventArgs e)
5174 DataGridViewRowCancelEventHandler eh = (DataGridViewRowCancelEventHandler)(Events [UserDeletingRowEvent]);
5175 if (eh != null) eh (this, e);
5178 protected override void OnValidating (CancelEventArgs e)
5180 base.OnValidating(e);
5183 protected override void OnVisibleChanged (EventArgs e)
5185 base.OnVisibleChanged(e);
5188 protected virtual void PaintBackground (Graphics graphics, Rectangle clipBounds, Rectangle gridBounds)
5190 graphics.FillRectangle (ThemeEngine.Current.ResPool.GetSolidBrush (backgroundColor), gridBounds);
5193 protected bool ProcessAKey (Keys keyData)
5198 if ((keyData & Keys.Control) == Keys.Control) {
5206 protected virtual bool ProcessDataGridViewKey (KeyEventArgs e)
5208 switch (e.KeyData & ~Keys.Modifiers) {
5210 return ProcessAKey (e.KeyData);
5212 return ProcessDeleteKey (e.KeyData);
5214 return ProcessDownKey (e.KeyData);
5216 return ProcessEscapeKey (e.KeyData);
5218 return ProcessEndKey (e.KeyData);
5220 return ProcessEnterKey (e.KeyData);
5222 return ProcessF2Key (e.KeyData);
5224 return ProcessHomeKey (e.KeyData);
5226 return ProcessLeftKey (e.KeyData);
5228 return ProcessNextKey (e.KeyData);
5230 return ProcessPriorKey (e.KeyData);
5232 return ProcessRightKey (e.KeyData);
5234 return ProcessSpaceKey (e.KeyData);
5236 return ProcessTabKey (e.KeyData);
5238 return ProcessUpKey (e.KeyData);
5241 return ProcessZeroKey (e.KeyData);
5247 protected bool ProcessDeleteKey (Keys keyData)
5249 if (!AllowUserToDeleteRows || SelectedRows.Count == 0)
5252 int index = Math.Max (selected_row - SelectedRows.Count + 1, 0);
5254 for (int i = SelectedRows.Count - 1; i >= 0; i--) {
5255 DataGridViewRow row = SelectedRows[i];
5260 if (hover_cell != null && hover_cell.OwningRow == row)
5263 if (DataManager != null)
5264 DataManager.RemoveAt (row.Index);
5266 Rows.RemoveAt (row.Index);
5272 protected override bool ProcessDialogKey (Keys keyData)
5276 case Keys.Shift | Keys.Tab:
5278 return base.ProcessDialogKey (keyData & ~Keys.Control);
5280 if (ProcessDataGridViewKey (new KeyEventArgs (keyData)))
5284 case Keys.Control | Keys.Tab:
5285 case Keys.Control | Keys.Shift | Keys.Tab:
5287 return base.ProcessDialogKey (keyData & ~Keys.Control);
5289 if (ProcessDataGridViewKey (new KeyEventArgs (keyData)))
5295 if (ProcessDataGridViewKey (new KeyEventArgs (keyData)))
5301 return base.ProcessDialogKey(keyData);
5304 protected bool ProcessDownKey (Keys keyData)
5306 int current_row = CurrentCellAddress.Y;
5308 if (current_row < Rows.Count - 1) {
5309 // Move to the last cell in the column
5310 if ((keyData & Keys.Control) == Keys.Control)
5311 MoveCurrentCell (CurrentCellAddress.X, Rows.Count - 1, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5312 // Move one cell down
5314 MoveCurrentCell (CurrentCellAddress.X, current_row + 1, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5322 protected bool ProcessEndKey (Keys keyData)
5324 int disp_index = ColumnIndexToDisplayIndex (currentCellAddress.X);
5326 // Move to the last cell in the control
5327 if ((keyData & Keys.Control) == Keys.Control) {
5328 MoveCurrentCell (ColumnDisplayIndexToIndex (Columns.Count - 1), Rows.Count - 1, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5332 // Move to the last cell in the row
5333 if (disp_index < Columns.Count - 1) {
5334 MoveCurrentCell (ColumnDisplayIndexToIndex (Columns.Count - 1), currentCellAddress.Y, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5341 protected bool ProcessEnterKey (Keys keyData)
5343 if (ProcessDownKey (keyData))
5346 // ProcessDown may fail if we are on the last row,
5347 // but Enter should still EndEdit if this is the last row
5352 protected bool ProcessEscapeKey (Keys keyData)
5354 if (!IsCurrentCellInEditMode)
5361 protected bool ProcessF2Key (Keys keyData)
5363 if (editMode == DataGridViewEditMode.EditOnF2 || editMode == DataGridViewEditMode.EditOnKeystrokeOrF2) {
5371 protected bool ProcessHomeKey (Keys keyData)
5373 int disp_index = ColumnIndexToDisplayIndex (currentCellAddress.X);
5375 // Move to the first cell in the control
5376 if ((keyData & Keys.Control) == Keys.Control) {
5377 MoveCurrentCell (ColumnDisplayIndexToIndex (0), 0, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5381 // Move to the first cell in the row
5382 if (disp_index > 0) {
5383 MoveCurrentCell (ColumnDisplayIndexToIndex (0), currentCellAddress.Y, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5390 [MonoInternalNote ("What does insert do?")]
5391 protected bool ProcessInsertKey (Keys keyData)
5396 protected override bool ProcessKeyEventArgs (ref Message m)
5398 DataGridViewCell cell = CurrentCell;
5401 if (cell.KeyEntersEditMode (new KeyEventArgs ((Keys)m.WParam.ToInt32 ())))
5403 if (EditingControl != null && ((Msg)m.Msg == Msg.WM_KEYDOWN || (Msg)m.Msg == Msg.WM_CHAR))
5404 XplatUI.SendMessage (EditingControl.Handle, (Msg)m.Msg, m.WParam, m.LParam);
5407 return base.ProcessKeyEventArgs (ref m);
5410 protected override bool ProcessKeyPreview (ref Message m)
5412 if ((Msg)m.Msg == Msg.WM_KEYDOWN && (IsCurrentCellInEditMode || m.HWnd == horizontalScrollBar.Handle || m.HWnd == verticalScrollBar.Handle)) {
5413 KeyEventArgs e = new KeyEventArgs ((Keys)m.WParam.ToInt32 ());
5415 IDataGridViewEditingControl ctrl = (IDataGridViewEditingControl)EditingControlInternal;
5418 if (ctrl.EditingControlWantsInputKey (e.KeyData, false))
5421 switch (e.KeyData) {
5430 return ProcessDataGridViewKey (e);
5434 return base.ProcessKeyPreview (ref m);
5437 protected bool ProcessLeftKey (Keys keyData)
5439 int disp_index = ColumnIndexToDisplayIndex (currentCellAddress.X);
5441 if (disp_index > 0) {
5442 // Move to the first cell in the row
5443 if ((keyData & Keys.Control) == Keys.Control)
5444 MoveCurrentCell (ColumnDisplayIndexToIndex (0), currentCellAddress.Y, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5445 // Move one cell to the left
5447 MoveCurrentCell (ColumnDisplayIndexToIndex (disp_index - 1), currentCellAddress.Y, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5456 protected bool ProcessNextKey (Keys keyData)
5458 int current_row = CurrentCellAddress.Y;
5460 if (current_row < Rows.Count - 1) {
5461 // Move one "page" of cells down
5462 int new_row = Math.Min (Rows.Count - 1, current_row + DisplayedRowCount (false));
5464 MoveCurrentCell (CurrentCellAddress.X, new_row, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5473 protected bool ProcessPriorKey (Keys keyData)
5475 int current_row = CurrentCellAddress.Y;
5477 if (current_row > 0) {
5478 // Move one "page" of cells up
5479 int new_row = Math.Max (0, current_row - DisplayedRowCount (false));
5481 MoveCurrentCell (CurrentCellAddress.X, new_row, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5489 protected bool ProcessRightKey (Keys keyData)
5491 int disp_index = ColumnIndexToDisplayIndex (currentCellAddress.X);
5493 if (disp_index < Columns.Count - 1) {
5494 // Move to the last cell in the row
5495 if ((keyData & Keys.Control) == Keys.Control)
5496 MoveCurrentCell (ColumnDisplayIndexToIndex (Columns.Count - 1), currentCellAddress.Y, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5497 // Move one cell to the right
5499 MoveCurrentCell (ColumnDisplayIndexToIndex (disp_index + 1), currentCellAddress.Y, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5507 protected bool ProcessSpaceKey (Keys keyData)
5509 if ((keyData & Keys.Shift) == Keys.Shift) {
5510 if (selectionMode == DataGridViewSelectionMode.RowHeaderSelect) {
5511 SetSelectedRowCore (CurrentCellAddress.Y, true);
5512 InvalidateRow (CurrentCellAddress.Y);
5515 if (selectionMode == DataGridViewSelectionMode.ColumnHeaderSelect) {
5516 SetSelectedColumnCore (CurrentCellAddress.X, true);
5517 InvalidateColumn (CurrentCellAddress.X);
5522 if (CurrentCell is DataGridViewButtonCell || CurrentCell is DataGridViewLinkCell || CurrentCell is DataGridViewCheckBoxCell) {
5523 DataGridViewCellEventArgs e = new DataGridViewCellEventArgs (CurrentCell.ColumnIndex, CurrentCell.RowIndex);
5526 OnCellContentClick (e);
5528 if (CurrentCell is DataGridViewButtonCell)
5529 (CurrentCell as DataGridViewButtonCell).OnClickInternal (e);
5530 if (CurrentCell is DataGridViewCheckBoxCell)
5531 (CurrentCell as DataGridViewCheckBoxCell).OnClickInternal (e);
5539 protected bool ProcessTabKey (Keys keyData)
5541 Form f = FindForm ();
5544 f.ActivateFocusCues ();
5546 int disp_index = ColumnIndexToDisplayIndex (currentCellAddress.X);
5549 // Shift-tab goes backwards
5550 if ((keyData & Keys.Shift) == Keys.Shift) {
5551 if (disp_index > 0) {
5552 // Move one cell to the left
5553 MoveCurrentCell (ColumnDisplayIndexToIndex (disp_index - 1), currentCellAddress.Y, true, (keyData & Keys.Control) == Keys.Control, false, true);
5555 } else if (currentCellAddress.Y > 0) {
5556 // Move to the last cell in the previous row
5557 MoveCurrentCell (ColumnDisplayIndexToIndex (Columns.Count - 1), currentCellAddress.Y - 1, true, false, false, true);
5562 if (disp_index < Columns.Count - 1) {
5563 // Move one cell to the right
5564 MoveCurrentCell (ColumnDisplayIndexToIndex (disp_index + 1), currentCellAddress.Y, true, (keyData & Keys.Control) == Keys.Control, false, true);
5567 } else if (currentCellAddress.Y < Rows.Count - 1) {
5568 // Move to the first cell in the next row
5569 MoveCurrentCell (ColumnDisplayIndexToIndex (0), currentCellAddress.Y + 1, true, false, false, true);
5579 protected bool ProcessUpKey (Keys keyData)
5581 int current_row = CurrentCellAddress.Y;
5583 if (current_row > 0) {
5584 // Move to the first cell in the column
5585 if ((keyData & Keys.Control) == Keys.Control)
5586 MoveCurrentCell (CurrentCellAddress.X, 0, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5589 MoveCurrentCell (CurrentCellAddress.X, current_row - 1, true, (keyData & Keys.Control) == Keys.Control, (keyData & Keys.Shift) == Keys.Shift, true);
5597 protected bool ProcessZeroKey (Keys keyData)
5599 if ((keyData & Keys.Control) == Keys.Control && CurrentCell.EditType != null) {
5600 CurrentCell.Value = DBNull.Value;
5601 InvalidateCell (CurrentCell);
5608 protected override void SetBoundsCore (int x, int y, int width, int height, BoundsSpecified specified) {
5609 base.SetBoundsCore(x, y, width, height, specified);
5612 [MonoTODO ("Does not use validateCurrentCell")]
5613 protected virtual bool SetCurrentCellAddressCore (int columnIndex, int rowIndex, bool setAnchorCellAddress, bool validateCurrentCell, bool throughMouseClick)
5615 if ((columnIndex < 0 || columnIndex > Columns.Count - 1) && rowIndex != -1)
5616 throw new ArgumentOutOfRangeException ("columnIndex");
5617 if ((rowIndex < 0 || rowIndex > Rows.Count - 1) && columnIndex != -1)
5618 throw new ArgumentOutOfRangeException ("rowIndex");
5620 DataGridViewCell cell;
5622 if (columnIndex == -1 && rowIndex == -1)
5625 cell = Rows.SharedRow (rowIndex).Cells[columnIndex];
5627 if (cell != null && !cell.Visible)
5628 throw new InvalidOperationException ("cell is not visible");
5630 // Always update the current cell address property
5631 // If the row has moved it would be out of date.
5632 if (currentCell != null) {
5633 if (setAnchorCellAddress) {
5634 anchor_cell.X = currentCell.ColumnIndex;
5635 anchor_cell.Y = currentCell.RowIndex;
5637 currentCellAddress.X = currentCell.ColumnIndex;
5638 currentCellAddress.Y = currentCell.RowIndex;
5641 if (cell != currentCell) {
5642 if (currentCell != null) {
5643 if (currentCell.IsInEditMode) {
5646 else if (currentCell.RowIndex == NewRowIndex && new_row_editing)
5649 // CancelEdit will replace the uncommited real editing row with a place holder row
5650 if (new_row_editing && currentCell.RowIndex == NewRowIndex)
5653 OnCellLeave (new DataGridViewCellEventArgs(currentCell.ColumnIndex, currentCell.RowIndex));
5654 OnRowLeave (new DataGridViewCellEventArgs (currentCell.ColumnIndex, currentCell.RowIndex));
5658 if (setAnchorCellAddress)
5659 anchor_cell = new Point (columnIndex, rowIndex);
5660 currentCellAddress = new Point (columnIndex, rowIndex);
5663 UpdateBindingPosition (cell.RowIndex);
5664 OnRowEnter (new DataGridViewCellEventArgs (cell.ColumnIndex, cell.RowIndex));
5665 OnCellEnter (new DataGridViewCellEventArgs(cell.ColumnIndex, cell.RowIndex));
5667 OnCurrentCellChanged (EventArgs.Empty);
5670 // If the user begins an edit in the NewRow, add a new real row
5671 if (AllowUserToAddRows && cell.RowIndex == NewRowIndex && !is_binding && !new_row_editing) {
5672 // OnUserAddedRow will add a real row and reset the current cell
5673 OnUserAddedRow (new DataGridViewRowEventArgs (Rows[NewRowIndex]));
5675 if (editMode == DataGridViewEditMode.EditOnEnter)
5680 if (cell != null && throughMouseClick)
5687 protected virtual void SetSelectedCellCore (int columnIndex, int rowIndex, bool selected) {
5688 rows [rowIndex].Cells [columnIndex].Selected = selected;
5690 OnSelectionChanged (EventArgs.Empty);
5693 internal void SetSelectedColumnCoreInternal (int columnIndex, bool selected) {
5694 SetSelectedColumnCore (columnIndex, selected);
5697 protected virtual void SetSelectedColumnCore (int columnIndex, bool selected) {
5698 if (selectionMode != DataGridViewSelectionMode.ColumnHeaderSelect && selectionMode != DataGridViewSelectionMode.FullColumnSelect)
5701 DataGridViewColumn col = columns [columnIndex];
5703 col.SelectedInternal = selected;
5705 if (selected_columns == null)
5706 selected_columns = new DataGridViewSelectedColumnCollection ();
5708 if (!selected && selected_columns.Contains (col)) {
5709 selected_columns.InternalRemove (col);
5710 } else if (selected && !selected_columns.Contains (col)) {
5711 selected_columns.InternalAdd (col);
5717 internal void SetSelectedRowCoreInternal (int rowIndex, bool selected) {
5718 if (rowIndex >= 0 && rowIndex < Rows.Count)
5719 SetSelectedRowCore (rowIndex, selected);
5722 protected virtual void SetSelectedRowCore (int rowIndex, bool selected) {
5723 DataGridViewRow row = rows [rowIndex];
5725 row.SelectedInternal = selected;
5727 if (selected_rows == null)
5728 selected_rows = new DataGridViewSelectedRowCollection (this);
5730 if (!selected && selected_rows.Contains (row)) {
5731 selected_rows.InternalRemove (row);
5732 } else if (selected && !selected_rows.Contains (row)) {
5733 selected_rows.InternalAdd (row);
5739 protected override void WndProc (ref Message m)
5741 base.WndProc (ref m);
5744 internal void InternalOnCellClick (DataGridViewCellEventArgs e)
5749 internal void InternalOnCellContentClick (DataGridViewCellEventArgs e)
5751 OnCellContentClick (e);
5754 internal void InternalOnCellContentDoubleClick (DataGridViewCellEventArgs e)
5756 OnCellContentDoubleClick (e);
5759 internal void InternalOnCellValueChanged (DataGridViewCellEventArgs e)
5761 OnCellValueChanged (e);
5764 internal void InternalOnDataError (DataGridViewDataErrorEventArgs e)
5766 /////////////// false? ////////////
5767 OnDataError (false, e);
5770 internal void InternalOnMouseWheel (MouseEventArgs e)
5775 internal void OnHScrollBarScroll (object sender, ScrollEventArgs e)
5777 int lastRightVisibleColumntIndex = Columns.Count - DisplayedColumnCount (false);
5778 horizontalScrollingOffset = e.NewValue;
5781 for (int index = 0; index < Columns.Count; index++) {
5782 DataGridViewColumn col = Columns[index];
5784 if (col.Index >= lastRightVisibleColumntIndex) {
5785 first_col_index = lastRightVisibleColumntIndex;
5788 } else if (e.NewValue < left + col.Width) {
5789 if (first_col_index != index) {
5790 first_col_index = index;
5802 internal void OnVScrollBarScroll (object sender, ScrollEventArgs e)
5804 verticalScrollingOffset = e.NewValue;
5805 if (Rows.Count == 0)
5809 int lastTopVisibleRowIndex = Rows.Count - DisplayedRowCount (false);
5811 for (int index = 0; index < Rows.Count; index++) {
5812 DataGridViewRow row = Rows[index];
5816 if (row.Index >= lastTopVisibleRowIndex) {
5817 first_row_index = lastTopVisibleRowIndex;
5820 } else if (e.NewValue < top + row.Height) {
5821 if (first_row_index != index) {
5822 first_row_index = index;
5833 first_row_index = lastTopVisibleRowIndex;
5838 internal void RaiseCellStyleChanged (DataGridViewCellEventArgs e) {
5839 OnCellStyleChanged(e);
5842 internal void OnColumnCollectionChanged (object sender, CollectionChangeEventArgs e) {
5844 case CollectionChangeAction.Add:
5845 OnColumnAddedInternal(new DataGridViewColumnEventArgs(e.Element as DataGridViewColumn));
5847 case CollectionChangeAction.Remove:
5848 OnColumnPostRemovedInternal(new DataGridViewColumnEventArgs(e.Element as DataGridViewColumn));
5850 case CollectionChangeAction.Refresh:
5852 MoveCurrentCell (-1, -1, true, false, false, true);
5857 // Resizes all columns according to their AutoResizeMode property.
5858 // First all the columns that aren't Filled are resized, then we resize all the Filled columns.
5859 internal void AutoResizeColumnsInternal ()
5861 for (int i = 0; i < Columns.Count; i++)
5862 AutoResizeColumnInternal (i, Columns [i].InheritedAutoSizeMode);
5864 AutoFillColumnsInternal ();
5867 internal void AutoFillColumnsInternal ()
5869 float totalFillWeight = 0;
5870 int FillCount = 0; // The number of columns that has AutoSizeMode.Fill set
5871 int spaceLeft = ClientSize.Width - (verticalScrollBar.VisibleInternal ? verticalScrollBar.Width : 0);
5873 if (RowHeadersVisible) {
5874 spaceLeft -= RowHeadersWidth;
5876 spaceLeft -= BorderWidth * 2;
5878 int [] fixed_widths = new int [Columns.Count];
5879 int [] new_widths = new int [Columns.Count];
5880 bool fixed_any = false;
5882 for (int i = 0; i < Columns.Count; i++) {
5883 DataGridViewColumn col = Columns [i];
5888 switch (col.InheritedAutoSizeMode) {
5889 case DataGridViewAutoSizeColumnMode.Fill:
5891 totalFillWeight += col.FillWeight;
5893 case DataGridViewAutoSizeColumnMode.AllCellsExceptHeader:
5894 case DataGridViewAutoSizeColumnMode.AllCells:
5895 case DataGridViewAutoSizeColumnMode.DisplayedCells:
5896 case DataGridViewAutoSizeColumnMode.DisplayedCellsExceptHeader:
5897 case DataGridViewAutoSizeColumnMode.None:
5898 case DataGridViewAutoSizeColumnMode.NotSet:
5899 spaceLeft -= Columns [i].Width;
5904 spaceLeft = Math.Max (0, spaceLeft);
5908 for (int i = 0; i < columns.Count; i++) {
5909 DataGridViewColumn col = Columns [i];
5912 if (col.InheritedAutoSizeMode != DataGridViewAutoSizeColumnMode.Fill)
5918 if (fixed_widths [i] != 0)
5921 width = (totalFillWeight == 0) ? 0 : (int) Math.Round (spaceLeft * (col.FillWeight / totalFillWeight), 0);
5926 if (width < col.MinimumWidth) {
5927 width = col.MinimumWidth;
5928 fixed_widths [i] = width;
5931 totalFillWeight -= col.FillWeight;
5934 new_widths [i] = width;
5936 } while (fixed_any);
5938 for (int i = 0; i < columns.Count; i++) {
5939 if (Columns [i].InheritedAutoSizeMode != DataGridViewAutoSizeColumnMode.Fill)
5942 if (!Columns[i].Visible)
5945 Columns [i].Width = new_widths [i];
5949 internal void AutoResizeColumnInternal (int columnIndex, DataGridViewAutoSizeColumnMode mode)
5951 // http://msdn2.microsoft.com/en-us/library/ms171605.aspx
5954 DataGridViewColumn col = Columns [columnIndex];
5957 case DataGridViewAutoSizeColumnMode.Fill:
5959 case DataGridViewAutoSizeColumnMode.AllCellsExceptHeader:
5960 case DataGridViewAutoSizeColumnMode.AllCells:
5961 case DataGridViewAutoSizeColumnMode.DisplayedCells:
5962 case DataGridViewAutoSizeColumnMode.DisplayedCellsExceptHeader:
5963 size = Math.Max (CalculateColumnCellWidth (columnIndex, col.InheritedAutoSizeMode),
5964 col.HeaderCell.ContentBounds.Width);
5966 case DataGridViewAutoSizeColumnMode.ColumnHeader:
5967 size = col.HeaderCell.ContentBounds.Width;
5976 if (size < col.MinimumWidth)
5977 size = col.MinimumWidth;
5982 internal int CalculateColumnCellWidth (int index, DataGridViewAutoSizeColumnMode mode)
5985 int last_row = Rows.Count;
5988 if (mode == DataGridViewAutoSizeColumnMode.DisplayedCells ||
5989 mode == DataGridViewAutoSizeColumnMode.DisplayedCellsExceptHeader) {
5990 first_row = first_row_index;
5991 last_row = DisplayedRowCount (true);;
5994 for (int i = first_row; i < last_row; i++) {
5995 if (!Rows[i].Visible)
5998 int cell_width = Rows[i].Cells[index].PreferredSize.Width;
5999 result = Math.Max (result, cell_width);
6005 Rectangle GetHeaderCellBounds (DataGridViewHeaderCell cell)
6007 Rectangle bounds = new Rectangle (ClientRectangle.Location, cell.Size);
6008 if (cell is DataGridViewColumnHeaderCell) {
6009 if (RowHeadersVisible)
6010 bounds.X += RowHeadersWidth;
6011 List<DataGridViewColumn> sortedColumns = columns.ColumnDisplayIndexSortedArrayList;
6012 for (int index = first_col_index; index < sortedColumns.Count; index++) {
6013 DataGridViewColumn column = sortedColumns [index];
6014 if (column.Index == cell.ColumnIndex)
6016 bounds.X += column.Width;
6019 if (ColumnHeadersVisible)
6020 bounds.Y += ColumnHeadersHeight;
6021 for (int index = first_row_index; index < Rows.Count; index++) {
6022 DataGridViewRow row = GetRowInternal (index);
6023 if (row.HeaderCell == cell)
6025 bounds.Y += row.Height;
6031 private void PrepareEditingRow (bool cell_changed, bool column_changed)
6033 if (new_row_editing)
6038 show = ColumnCount > 0 && AllowUserToAddRows;
6041 RemoveEditingRow ();
6043 if (editing_row != null && (cell_changed || column_changed)) {
6044 // The row changed, it's no longer an editing row.
6046 // The number of columns has changed, we need a new editing row.
6047 RemoveEditingRow ();
6049 if (editing_row == null) {
6050 editing_row = RowTemplateFull;
6051 Rows.AddInternal (editing_row, false);
6056 internal void RemoveEditingRow ()
6058 if (editing_row != null) {
6059 if (Rows.Contains (editing_row))
6060 Rows.RemoveInternal (editing_row);
6065 internal DataGridViewRow EditingRow {
6066 get { return editing_row; }
6069 private void AddBoundRow (object element)
6071 // Don't add rows if there are no columns
6072 if (ColumnCount == 0)
6075 DataGridViewRow row = (DataGridViewRow)RowTemplateFull;
6076 rows.AddInternal (row, false);
6079 private bool IsColumnAlreadyBound (string name)
6081 foreach (DataGridViewColumn col in Columns)
6082 if (String.Compare (col.DataPropertyName, name, true) == 0)
6088 private DataGridViewColumn CreateColumnByType (Type type)
6090 if (type == typeof (bool))
6091 return new DataGridViewCheckBoxColumn ();
6092 else if (typeof(Bitmap).IsAssignableFrom (type))
6093 return new DataGridViewImageColumn ();
6095 return new DataGridViewTextBoxColumn ();
6098 private void ClearBinding ()
6100 if (IsCurrentCellInEditMode && !EndEdit ())
6102 MoveCurrentCell (-1, -1, false, false, false, true);
6104 if (DataManager != null) {
6105 DataManager.ListChanged -= OnListChanged;
6106 DataManager.PositionChanged -= OnListPositionChanged;
6107 columns.ClearAutoGeneratedColumns ();
6109 RemoveEditingRow ();
6113 private void ResetRows ()
6116 RemoveEditingRow ();
6117 if (DataManager != null) {
6118 foreach (object element in DataManager.List)
6119 AddBoundRow (element);
6121 PrepareEditingRow (false, true);
6122 OnListPositionChanged (this, EventArgs.Empty);
6125 private void DoBinding ()
6127 /* 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:
6128 - the System.Collections.IList interface, including one-dimensional arrays.
6129 - the System.ComponentModel.IListSource interface, such as the System.Data.DataTable and System.Data.DataSet classes.
6130 - the System.ComponentModel.IBindingList interface, such as the System.ComponentModel.Collections.BindingList<> class.
6131 - the System.ComponentModel.IBindingListView interface, such as the System.Windows.Forms.BindingSource class.
6134 if (dataSource != null && DataManager != null) {
6135 if (autoGenerateColumns) {
6136 is_autogenerating_columns = true;
6138 foreach (PropertyDescriptor property in DataManager.GetItemProperties()) {
6139 // This keeps out things like arrays
6140 if ((typeof(ICollection).IsAssignableFrom (property.PropertyType)))
6142 if (!property.IsBrowsable)
6145 if (IsColumnAlreadyBound (property.Name))
6148 DataGridViewColumn col = CreateColumnByType (property.PropertyType);
6149 col.Name = property.DisplayName;
6150 col.DataPropertyName = property.Name;
6151 col.ReadOnly = !DataManager.AllowEdit || property.IsReadOnly;
6152 col.ValueType = property.PropertyType;
6153 col.AutoGenerated = true;
6157 is_autogenerating_columns = false;
6160 // DataBind both autogenerated and not columns if there is a matching property
6161 foreach (DataGridViewColumn column in columns)
6162 column.DataColumnIndex = FindDataColumnIndex (column);
6164 foreach (object element in DataManager.List)
6165 AddBoundRow (element);
6167 DataManager.ListChanged += OnListChanged;
6168 DataManager.PositionChanged += OnListPositionChanged;
6169 OnDataBindingComplete (new DataGridViewBindingCompleteEventArgs (ListChangedType.Reset));
6170 OnListPositionChanged (this, EventArgs.Empty);
6172 if (Rows.Count > 0 && Columns.Count > 0)
6173 MoveCurrentCell (0, 0, true, false, false, false);
6176 PrepareEditingRow (false, true);
6179 private void MoveCurrentCell (int x, int y, bool select, bool isControl, bool isShift, bool scroll)
6181 if (x == -1 || y == -1)
6184 if (x < 0 || x > Columns.Count - 1)
6185 throw new ArgumentOutOfRangeException ("x");
6186 if (y < 0 || y > Rows.Count - 1)
6187 throw new ArgumentOutOfRangeException ("y");
6189 if (!Rows[y].Visible) {
6190 for (int i = y; i < Rows.Count; i++) {
6191 if (Rows[i].Visible) {
6198 if (!Columns[x].Visible) {
6199 for (int i = x; i < Columns.Count; i++) {
6200 if (Columns[i].Visible) {
6207 // in case either no visible columns or rows
6208 if (!Rows[y].Visible || !Columns[x].Visible)
6212 if (!SetCurrentCellAddressCore (x, y, true, false, false)) {
6216 if (x == -1 && y == -1) {
6221 bool full_row_selected = Rows.SharedRow(CurrentCellAddress.Y).Selected;
6222 bool full_col_selected = Columns[CurrentCellAddress.X].Selected;
6225 DataGridViewSelectionMode mode = selectionMode;
6227 // If we are row header select and we clicked a row header, use full row
6228 if (mode == DataGridViewSelectionMode.RowHeaderSelect && (x == -1 || (full_row_selected && CurrentCellAddress.X == x)))
6229 mode = DataGridViewSelectionMode.FullRowSelect;
6230 else if (mode == DataGridViewSelectionMode.RowHeaderSelect)
6231 mode = DataGridViewSelectionMode.CellSelect;
6233 // If we are col header select and we clicked a col header, use full col
6234 if (mode == DataGridViewSelectionMode.ColumnHeaderSelect && (y == -1 || (full_col_selected && CurrentCellAddress.Y == y)))
6235 mode = DataGridViewSelectionMode.FullColumnSelect;
6236 else if (mode == DataGridViewSelectionMode.ColumnHeaderSelect)
6237 mode = DataGridViewSelectionMode.CellSelect;
6239 // If the current cell isn't visible, scroll to it
6241 int disp_x = ColumnIndexToDisplayIndex (x);
6242 bool scrollbarsRefreshed = false;
6243 int displayedColumnsCount = DisplayedColumnCount (false);
6246 // The trick here is that in order to avoid unnecessary calculations each time a row/column
6247 // is added/removed we recalculate the whole grid size just before the scroll to selection.
6248 if (disp_x < first_col_index) {
6249 RefreshScrollBars ();
6250 scrollbarsRefreshed = true;
6253 delta_x = horizontalScrollBar.Value;
6255 // in case the column got removed
6256 if (first_col_index >= ColumnCount)
6257 first_col_index = ColumnCount - 1;
6258 for (int i = disp_x; i < first_col_index; i++)
6259 delta_x += Columns[ColumnDisplayIndexToIndex (i)].Width;
6262 horizontalScrollBar.SafeValueSet (horizontalScrollBar.Value - delta_x);
6263 OnHScrollBarScroll (this, new ScrollEventArgs (ScrollEventType.ThumbPosition, horizontalScrollBar.Value));
6264 } else if (disp_x > first_col_index + displayedColumnsCount - 1) {
6265 RefreshScrollBars ();
6266 scrollbarsRefreshed = true;
6268 if (disp_x == Columns.Count - 1)
6269 delta_x = horizontalScrollBar.Maximum - horizontalScrollBar.Value;
6271 for (int i = first_col_index + displayedColumnsCount - 1; i < disp_x; i++)
6272 delta_x += Columns[ColumnDisplayIndexToIndex (i)].Width;
6274 horizontalScrollBar.SafeValueSet (horizontalScrollBar.Value + delta_x);
6275 OnHScrollBarScroll (this, new ScrollEventArgs (ScrollEventType.ThumbPosition, horizontalScrollBar.Value));
6279 int displayedRowsCount = DisplayedRowCount (false);
6282 if (disp_y < first_row_index) {
6283 if (!scrollbarsRefreshed)
6284 RefreshScrollBars ();
6287 delta_y = verticalScrollBar.Value;
6289 // in case the row got removed
6290 if (first_row_index >= RowCount)
6291 first_row_index = RowCount - 1;
6292 for (int i = disp_y; i < first_row_index; i++)
6293 delta_y += GetRowInternal (i).Height;
6296 verticalScrollBar.SafeValueSet (verticalScrollBar.Value - delta_y);
6297 OnVScrollBarScroll (this, new ScrollEventArgs (ScrollEventType.ThumbPosition, verticalScrollBar.Value));
6298 } else if (disp_y > first_row_index + displayedRowsCount - 1) {
6299 if (!scrollbarsRefreshed)
6300 RefreshScrollBars ();
6302 if (disp_y == Rows.Count - 1)
6303 delta_y = verticalScrollBar.Maximum - verticalScrollBar.Value;
6305 for (int i = first_row_index + displayedRowsCount - 1; i < disp_y; i++)
6306 delta_y += GetRowInternal (i).Height;
6308 verticalScrollBar.SafeValueSet (verticalScrollBar.Value + delta_y);
6309 OnVScrollBarScroll (this, new ScrollEventArgs (ScrollEventType.ThumbPosition, verticalScrollBar.Value));
6316 // Clear old selection unless multi-selecting
6321 case DataGridViewSelectionMode.CellSelect:
6322 SetSelectedCellCore (x, y, true);
6324 case DataGridViewSelectionMode.FullRowSelect:
6325 SetSelectedRowCore (y, true);
6327 case DataGridViewSelectionMode.FullColumnSelect:
6328 SetSelectedColumnCore (x, true);
6335 private int ColumnIndexToDisplayIndex (int index)
6339 return Columns[index].DisplayIndex;
6342 private int ColumnDisplayIndexToIndex (int index)
6344 return Columns.ColumnDisplayIndexSortedArrayList[index].Index;
6347 private void OnListChanged (object sender, ListChangedEventArgs args)
6349 switch (args.ListChangedType) {
6350 case ListChangedType.ItemAdded:
6351 AddBoundRow (DataManager[args.NewIndex]);
6353 case ListChangedType.ItemDeleted:
6354 Rows.RemoveAtInternal (args.NewIndex);
6356 case ListChangedType.ItemChanged:
6366 private void OnListPositionChanged (object sender, EventArgs args)
6368 if (Rows.Count > 0 && Columns.Count > 0 && DataManager.Position != -1)
6369 MoveCurrentCell (currentCell != null ? currentCell.ColumnIndex : 0, DataManager.Position,
6370 true, false, false, true);
6372 MoveCurrentCell (-1, -1, true, false, false, true);
6375 private void ReBind ()
6385 ResumeLayout (true);
6390 private bool MouseOverColumnResize (int col, int mousex)
6392 if (!allowUserToResizeColumns)
6395 Rectangle col_bounds = GetCellDisplayRectangle (col, 0, false);
6397 if (mousex >= col_bounds.Right - 4 && mousex <= col_bounds.Right)
6403 private bool MouseOverRowResize (int row, int mousey)
6405 if (!allowUserToResizeRows)
6408 Rectangle row_bounds = GetCellDisplayRectangle (0, row, false);
6410 if (mousey >= row_bounds.Bottom - 4 && mousey <= row_bounds.Bottom)
6416 private void DrawVerticalResizeLine (int x)
6418 Rectangle splitter = new Rectangle (x, Bounds.Y + 3 + (ColumnHeadersVisible ? ColumnHeadersHeight : 0), 1, Bounds.Height - 3 - (ColumnHeadersVisible ? ColumnHeadersHeight : 0));
6419 XplatUI.DrawReversibleRectangle (Handle, splitter, 2);
6422 private void DrawHorizontalResizeLine (int y)
6424 Rectangle splitter = new Rectangle (Bounds.X + 3 + (RowHeadersVisible ? RowHeadersWidth : 0), y, Bounds.Width - 3 + (RowHeadersVisible ? RowHeadersWidth : 0), 1);
6425 XplatUI.DrawReversibleRectangle (Handle, splitter, 2);
6428 #region Stuff for ToolTips
6429 private void MouseEnteredErrorIcon (DataGridViewCell item)
6431 tooltip_currently_showing = item;
6432 ToolTipTimer.Start ();
6435 private void MouseLeftErrorIcon (DataGridViewCell item)
6437 ToolTipTimer.Stop ();
6438 ToolTipWindow.Hide (this);
6439 tooltip_currently_showing = null;
6442 private Timer ToolTipTimer {
6444 if (tooltip_timer == null) {
6445 tooltip_timer = new Timer ();
6446 tooltip_timer.Enabled = false;
6447 tooltip_timer.Interval = 500;
6448 tooltip_timer.Tick += new EventHandler (ToolTipTimer_Tick);
6451 return tooltip_timer;
6455 private ToolTip ToolTipWindow {
6457 if (tooltip_window == null)
6458 tooltip_window = new ToolTip ();
6460 return tooltip_window;
6464 private void ToolTipTimer_Tick (object o, EventArgs args)
6466 string tooltip = tooltip_currently_showing.ErrorText;
6468 if (!string.IsNullOrEmpty (tooltip))
6469 ToolTipWindow.Present (this, tooltip);
6471 ToolTipTimer.Stop ();
6475 private class ColumnSorter : IComparer
6481 public ColumnSorter (DataGridViewColumn column, ListSortDirection direction, bool numeric)
6483 this.column = column.Index;
6484 this.numeric_sort = numeric;
6486 if (direction == ListSortDirection.Descending)
6487 this.direction = -1;
6490 #region IComparer Members
6491 public int Compare (object x, object y)
6493 DataGridViewRow row1 = (DataGridViewRow)x;
6494 DataGridViewRow row2 = (DataGridViewRow)y;
6496 if (row1.Cells[column].ValueType == typeof (DateTime) && row2.Cells[column].ValueType == typeof (DateTime))
6497 return DateTime.Compare ((DateTime)row1.Cells[column].Value, (DateTime)row2.Cells[column].Value) * direction;
6499 object val1 = row1.Cells[column].FormattedValue;
6500 object val2 = row2.Cells[column].FormattedValue;
6501 object val1NullValue = row1.Cells[column].InheritedStyle.NullValue;
6502 object val2NullValue = row2.Cells[column].InheritedStyle.NullValue;
6504 if (val1 == val1NullValue && val2 == val2NullValue)
6506 if (val1 == val1NullValue)
6508 if (val2 == val2NullValue)
6509 return -1 * direction;
6512 return (int)(double.Parse (val1.ToString ()) - double.Parse (val2.ToString ())) * direction;
6514 return string.Compare (val1.ToString (), val2.ToString ()) * direction;
6519 public sealed class HitTestInfo {
6521 public static readonly HitTestInfo Nowhere = new HitTestInfo(-1, -1, -1, -1, DataGridViewHitTestType.None);
6523 private int columnIndex;
6524 private int columnX;
6525 private int rowIndex;
6527 private DataGridViewHitTestType type;
6529 internal HitTestInfo (int columnIndex, int columnX, int rowIndex, int rowY, DataGridViewHitTestType type) {
6530 this.columnIndex = columnIndex;
6531 this.columnX = columnX;
6532 this.rowIndex = rowIndex;
6537 public int ColumnIndex {
6538 get { return columnIndex; }
6541 public int ColumnX {
6542 get { return columnX; }
6545 public int RowIndex {
6546 get { return rowIndex; }
6550 get { return rowY; }
6553 public DataGridViewHitTestType Type {
6554 get { return type; }
6557 public override bool Equals (object value) {
6558 if (value is HitTestInfo) {
6559 HitTestInfo aux = (HitTestInfo) value;
6560 if (aux.columnIndex == columnIndex && aux.columnX == columnX && aux.rowIndex == rowIndex && aux.rowY == rowY && aux.type == type) {
6567 public override int GetHashCode () {
6568 return base.GetHashCode();
6571 public override string ToString () {
6572 return string.Format ("Type:{0}, Column:{1}, Row:{2}", type, columnIndex, rowIndex);
6577 [ComVisible (false)]
6578 public class DataGridViewControlCollection : Control.ControlCollection
6580 private DataGridView owner;
6582 public DataGridViewControlCollection (DataGridView owner) : base (owner)
6587 public override void Clear ()
6590 // This is severely buggy, just as MS' implementation is.
6592 for (int i = 0; i < Count; i++) {
6597 public void CopyTo (Control [] array, int index)
6599 base.CopyTo (array, index);
6602 public void Insert (int index, Control value)
6604 throw new NotSupportedException ();
6607 public override void Remove (Control value)
6609 if (value == owner.horizontalScrollBar)
6612 if (value == owner.verticalScrollBar)
6615 if (value == owner.editingControl)
6618 base.Remove (value);
6621 internal void RemoveInternal (Control value)
6623 base.Remove (value);
6629 [ComVisibleAttribute(true)]
6630 protected class DataGridViewAccessibleObject : ControlAccessibleObject {
6632 public DataGridViewAccessibleObject (DataGridView owner) : base (owner){
6635 public override AccessibleRole Role {
6636 get { return base.Role; }
6639 public override string Name {
6640 get { return base.Name; }
6643 public override AccessibleObject GetChild (int index) {
6644 return base.GetChild(index);
6647 public override int GetChildCount () {
6648 return base.GetChildCount();
6651 public override AccessibleObject GetFocused () {
6652 return base.GetFocused();
6655 public override AccessibleObject GetSelected () {
6656 return base.GetSelected();
6659 public override AccessibleObject HitTest (int x, int y) {
6660 return base.HitTest(x, y);
6663 public override AccessibleObject Navigate( AccessibleNavigation navigationDirection) {
6664 return base.Navigate(navigationDirection);
6670 protected class DataGridViewTopRowAccessibleObject : AccessibleObject
6672 #region Constructors
6673 public DataGridViewTopRowAccessibleObject ()
6677 public DataGridViewTopRowAccessibleObject (DataGridView owner)
6683 #region Public Methods
6684 public override AccessibleObject GetChild (int index)
6686 return base.GetChild (index);
6689 public override int GetChildCount ()
6691 return base.GetChildCount ();
6694 public override AccessibleObject Navigate (AccessibleNavigation navigationDirection)
6696 return base.Navigate (navigationDirection);
6700 #region Public Properties
6701 public override Rectangle Bounds {
6702 get { return base.Bounds; }
6705 public override string Name {
6706 get { return base.Name; }
6709 public DataGridView Owner {
6710 get { return (DataGridView)owner; }
6713 throw new InvalidOperationException ("owner has already been set");
6719 public override AccessibleObject Parent {
6720 get { return base.Parent; }
6723 public override AccessibleRole Role {
6724 get { return base.Role; }
6727 public override string Value {
6728 get { return base.Value; }