diff options
Diffstat (limited to 'mcs/class/Managed.Windows.Forms/System.Windows.Forms/DataGrid.cs')
| -rw-r--r-- | mcs/class/Managed.Windows.Forms/System.Windows.Forms/DataGrid.cs | 2190 |
1 files changed, 2190 insertions, 0 deletions
diff --git a/mcs/class/Managed.Windows.Forms/System.Windows.Forms/DataGrid.cs b/mcs/class/Managed.Windows.Forms/System.Windows.Forms/DataGrid.cs new file mode 100644 index 00000000000..03d6d49d3d4 --- /dev/null +++ b/mcs/class/Managed.Windows.Forms/System.Windows.Forms/DataGrid.cs @@ -0,0 +1,2190 @@ +// Permission is hereby granted, free of charge, to any person obtaining +// a copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to +// permit persons to whom the Software is furnished to do so, subject to +// the following conditions: +// +// The above copyright notice and this permission notice shall be +// included in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +// +// Copyright (c) 2005 Novell, Inc. (http://www.novell.com) +// +// Author: +// Jordi Mas i Hernandez <jordi@ximian.com> +// +// + +// NOT COMPLETE + + +using System; +using System.ComponentModel; +using System.Drawing; +using System.Runtime.InteropServices; +using System.Collections; + +namespace System.Windows.Forms +{ + [DefaultEvent("Navigate")] + [DefaultProperty("DataSource")] + [Designer("System.Windows.Forms.Design.DataGridDesigner, " + Consts.AssemblySystem_Design, "System.ComponentModel.Design.IDesigner")] + public class DataGrid : Control, ISupportInitialize, IDataGridEditingService + { + [Flags] + [Serializable] + public enum HitTestType + { + None = 0, + Cell = 1, + ColumnHeader = 2, + RowHeader = 4, + ColumnResize = 8, + RowResize = 16, + Caption = 32, + ParentRows = 64 + } + + public sealed class HitTestInfo + { + public static readonly HitTestInfo Nowhere = null; + + #region Local Variables + internal int column; + internal int row; + internal HitTestType type; + #endregion // Local Variables + + #region Private Constructors + internal HitTestInfo () + { + column = -1; + row = -1; + type = HitTestType.None; + } + #endregion + + + #region Public Instance Properties + public int Column { + get { return column; } + } + + public int Row { + get { return row; } + } + public DataGrid.HitTestType Type { + get { return type; } + } + #endregion //Public Instance Properties + + public override bool Equals (object o) + { + if (!(o is HitTestInfo)) + return false; + + HitTestInfo obj = (HitTestInfo) o; + return (obj.Column == column && obj.Row == row && obj.Type ==type); + } + + public override int GetHashCode () + { + return row ^ column; + } + + public override string ToString () + { + return "{ " + type + "," + row + "," + column + "}"; + } + + } + + #region Local Variables + private static readonly Color def_alternating_backcolor = ThemeEngine.Current.DataGridAlternatingBackColor; + private static readonly Color def_background_color = ThemeEngine.Current.DataGridBackgroundColor; + private static readonly Color def_caption_backcolor = ThemeEngine.Current.DataGridCaptionBackColor; + private static readonly Color def_caption_forecolor = ThemeEngine.Current.DataGridCaptionForeColor; + private static readonly Color def_gridline_color = ThemeEngine.Current.DataGridGridLineColor; + private static readonly Color def_header_backcolor = ThemeEngine.Current.DataGridHeaderBackColor; + private static readonly Font def_header_font = ThemeEngine.Current.DefaultFont; + private static readonly Color def_header_forecolor = ThemeEngine.Current.DataGridHeaderForeColor; + private static readonly Color def_link_hovercolor = ThemeEngine.Current.DataGridLinkHoverColor; + private static readonly Color def_parentrowsback_color = ThemeEngine.Current.DataGridParentRowsBackColor; + private static readonly Color def_parentrowsfore_color = ThemeEngine.Current.DataGridParentRowsForeColor; + private static readonly Color def_selection_backcolor = ThemeEngine.Current.DataGridSelectionBackColor; + private static readonly Color def_selection_forecolor = ThemeEngine.Current.DataGridSelectionForeColor; + private static readonly Color def_link_color = ThemeEngine.Current.DataGridLinkColor; + internal readonly int def_preferredrow_height; + + private bool allow_navigation; + private bool allow_sorting; + private Color alternating_backcolor; + private Color backColor; + private Color background_color; + private Color caption_backcolor; + private Font caption_font; + private Color caption_forecolor; + private string caption_text; + internal bool caption_visible; + internal bool columnheaders_visible; + private object datasource; + private object real_datasource; + private string datamember; + private int firstvisible_column; + private bool flatmode; + private Color gridline_color; + private DataGridLineStyle gridline_style; + private Color header_backcolor; + private Color header_forecolor; + private Font header_font; + private Color link_color; + private Color link_hovercolor; + private Color parentrowsback_color; + private Color parentrowsfore_color; + private bool parentrows_visible; + private int preferredcolumn_width; + private int preferredrow_height; + private bool _readonly; + internal bool rowheaders_visible; + private Color selection_backcolor; + private Color selection_forecolor; + private int rowheaders_width; + internal int visiblecolumn_count; + internal int visiblerow_count; + internal int first_visiblecolumn; + private GridTableStylesCollection styles_collection; + private DataGridParentRowsLabelStyle parentrowslabel_style; + internal DataGridCell current_cell; + private DataGridTableStyle default_style; + private DataGridTableStyle current_style; + internal HScrollBar horiz_scrollbar; + internal VScrollBar vert_scrollbar; + internal DataGridDrawing grid_drawing; + internal int first_visiblerow; + internal int horz_pixeloffset; + internal bool is_editing; // Current cell is edit mode + internal bool is_changing; // Indicates if current cell is been changed (in edit mode) + internal bool is_adding; // Indicates when we are adding a row + private Hashtable selected_rows; + private bool ctrl_pressed; + private bool shift_pressed; + private bool begininit; + private CurrencyManager cached_currencymgr; + private CurrencyManager cached_currencymgr_events; + private bool accept_listmgrevents; + #endregion // Local Variables + + #region Public Constructors + public DataGrid () + { + grid_drawing = new DataGridDrawing (this); + allow_navigation = true; + allow_sorting = true; + begininit = false; + backColor = ThemeEngine.Current.DataGridBackColor; + alternating_backcolor = def_alternating_backcolor; + background_color = def_background_color; + border_style = BorderStyle.Fixed3D; + caption_backcolor = def_caption_backcolor; + caption_font = null; + caption_forecolor = def_caption_forecolor; + caption_text = string.Empty; + caption_visible = true; + columnheaders_visible = true; + datasource = null; + real_datasource = null; + datamember = string.Empty; + firstvisible_column = 0; + flatmode = false; + gridline_color = def_gridline_color; + gridline_style = DataGridLineStyle.Solid; + header_backcolor = def_header_backcolor; + header_forecolor = def_header_forecolor; + header_font = def_header_font; + link_color = def_link_color; + link_hovercolor = def_link_hovercolor; + parentrowsback_color = def_parentrowsback_color; + parentrowsfore_color = def_parentrowsfore_color; + parentrows_visible = true; + preferredcolumn_width = ThemeEngine.Current.DataGridPreferredColumnWidth; + _readonly = false; + rowheaders_visible = true; + selection_backcolor = def_selection_backcolor; + selection_forecolor = def_selection_forecolor; + rowheaders_width = 35; + visiblecolumn_count = 0; + visiblerow_count = 0; + current_cell = new DataGridCell (); + first_visiblerow = 0; + first_visiblecolumn = 0; + horz_pixeloffset = 0; + is_editing = false; + is_changing = false; + is_adding = false; + parentrowslabel_style = DataGridParentRowsLabelStyle.Both; + selected_rows = new Hashtable (); + ctrl_pressed = false; + shift_pressed = false; + preferredrow_height = def_preferredrow_height = FontHeight + 3; + cached_currencymgr_events = cached_currencymgr = null; + accept_listmgrevents = true; + + default_style = new DataGridTableStyle (true); + styles_collection = new GridTableStylesCollection (this); + styles_collection.CollectionChanged += new CollectionChangeEventHandler (OnTableStylesCollectionChanged); + + CurrentTableStyle = default_style; + + horiz_scrollbar = new HScrollBar (); + horiz_scrollbar.Scroll += new ScrollEventHandler (GridHScrolled); + vert_scrollbar = new VScrollBar (); + vert_scrollbar.Scroll += new ScrollEventHandler (GridVScrolled); + KeyUp += new KeyEventHandler (OnKeyUpDG); + + SetStyle (ControlStyles.UserMouse, true); + + } + + #endregion // Public Constructor + + #region Public Instance Properties + + [DefaultValue(true)] + public bool AllowNavigation { + get { + return allow_navigation; + } + + set { + if (allow_navigation != value) { + allow_navigation = value; + OnAllowNavigationChanged (EventArgs.Empty); + } + } + } + + [DefaultValue(true)] + public bool AllowSorting { + get { + return allow_sorting; + } + + set { + if (allow_sorting != value) { + allow_sorting = value; + } + } + } + + public Color AlternatingBackColor { + get { + return alternating_backcolor; + } + + set { + if (alternating_backcolor != value) { + alternating_backcolor = value; + Refresh (); + } + } + } + + public override Color BackColor { + get { + return backColor; + } + set { + backColor = value; + } + } + + public Color BackgroundColor { + get { + return background_color; + } + set { + if (background_color != value) { + background_color = value; + OnBackgroundColorChanged (EventArgs.Empty); + Refresh (); + } + } + } + + [Browsable(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public override Image BackgroundImage { + get { + return base.BackgroundImage; + } + + set { + base.BackgroundImage = value; + } + } + + [DispId(-504)] + [DefaultValue(BorderStyle.Fixed3D)] + public BorderStyle BorderStyle { + get { return InternalBorderStyle; } + set { + InternalBorderStyle = value; + CalcAreasAndInvalidate (); + OnBorderStyleChanged (EventArgs.Empty); + } + } + + public Color CaptionBackColor { + get { + return caption_backcolor; + } + + set { + if (caption_backcolor != value) { + caption_backcolor = value; + grid_drawing.InvalidateCaption (); + } + } + } + + [Localizable(true)] + [AmbientValue(null)] + public Font CaptionFont { + get { + if (caption_font == null) { + return Font; + } + + return caption_font; + } + + set { + if (caption_font != null && caption_font.Equals (value)) { + return; + } + + caption_font = value; + CalcAreasAndInvalidate (); + } + } + + public Color CaptionForeColor { + get { + return caption_forecolor; + } + + set { + if (caption_forecolor != value) { + caption_forecolor = value; + grid_drawing.InvalidateCaption (); + } + } + } + + [Localizable(true)] + [DefaultValue("")] + public string CaptionText { + get { + return caption_text; + } + + set { + if (caption_text != value) { + caption_text = value; + grid_drawing.InvalidateCaption (); + } + } + } + + [DefaultValue(true)] + public bool CaptionVisible { + get { + return caption_visible; + } + + set { + if (caption_visible != value) { + caption_visible = value; + CalcAreasAndInvalidate (); + OnCaptionVisibleChanged (EventArgs.Empty); + } + } + } + + [DefaultValue(true)] + public bool ColumnHeadersVisible { + get { + return columnheaders_visible; + } + + set { + if (columnheaders_visible != value) { + columnheaders_visible = value; + CalcAreasAndInvalidate (); + } + } + } + + [Browsable(false)] + [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)] + public DataGridCell CurrentCell { + get { + return current_cell; + } + + set { + if (!current_cell.Equals (value)) { + CancelEditing (); + + int old_row = current_cell.RowNumber; + + if (value.RowNumber >= RowsCount) { + value.RowNumber = RowsCount == 0 ? 0 : RowsCount - 1; + } + + if (value.ColumnNumber >= CurrentTableStyle.GridColumnStyles.Count) { + value.ColumnNumber = CurrentTableStyle.GridColumnStyles.Count == 0 ? 0: CurrentTableStyle.GridColumnStyles.Count - 1; + } + + EnsureCellVisilibility (value); + current_cell = value; + + if (current_cell.RowNumber != old_row) { + grid_drawing.InvalidateRowHeader (old_row); + } + + accept_listmgrevents = false; + + if (cached_currencymgr_events != null) { + cached_currencymgr_events.Position = current_cell.RowNumber; + } + accept_listmgrevents = true; + InvalidateCurrentRowHeader (); + OnCurrentCellChanged (EventArgs.Empty); + } + } + } + + [Browsable(false)] + [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)] + public int CurrentRowIndex { + get { + if (ListManager == null) { + return -1; + } + + return current_cell.RowNumber; + } + + set { + if (current_cell.RowNumber != value) { + CurrentCell = new DataGridCell (value, current_cell.ColumnNumber); + } + } + } + + [Browsable(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public override Cursor Cursor { + get { + return base.Cursor; + } + set { + base.Cursor = value; + } + } + + [DefaultValue(null)] + [Editor ("System.Windows.Forms.Design.DataMemberListEditor, " + Consts.AssemblySystem_Design, "System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)] + public string DataMember { + get { return datamember; } + set { + if (SetDataMember (value)) { + SetDataSource (datasource); + if (styles_collection.Contains (value) == true) { + CurrentTableStyle = styles_collection[value]; + current_style.CreateColumnsForTable (false); + } else { + CurrentTableStyle = default_style; + current_style.GridColumnStyles.Clear (); + current_style.CreateColumnsForTable (false); + } + } + } + } + + [DefaultValue(null)] + [RefreshProperties(RefreshProperties.Repaint)] + [TypeConverter("System.Windows.Forms.Design.DataSourceConverter, " + Consts.AssemblySystem_Design)] + public object DataSource { + get { + return datasource; + } + + set { + if (SetDataSource (value)) { + SetNewDataSource (); + } + } + } + + protected override Size DefaultSize { + get { + return new Size (130, 80); + } + } + + [Browsable(false)] + public int FirstVisibleColumn { + get { + return firstvisible_column; + } + } + + [DefaultValue(false)] + public bool FlatMode { + get { + return flatmode; + } + + set { + if (flatmode != value) { + flatmode = value; + OnFlatModeChanged (EventArgs.Empty); + Refresh (); + } + } + } + + public override Color ForeColor { + get { + return base.ForeColor; + } + + set { + base.ForeColor = value; + } + } + + public Color GridLineColor { + get { + return gridline_color; + } + + set { + if (value == Color.Empty) { + throw new ArgumentException ("Color.Empty value is invalid."); + } + + if (gridline_color != value) { + gridline_color = value; + Refresh (); + } + } + } + + [DefaultValue(DataGridLineStyle.Solid)] + public DataGridLineStyle GridLineStyle { + get { + return gridline_style; + } + + set { + if (gridline_style != value) { + gridline_style = value; + Refresh (); + } + } + } + + public Color HeaderBackColor { + get { + return header_backcolor; + } + + set { + if (value == Color.Empty) { + throw new ArgumentException ("Color.Empty value is invalid."); + } + + if (header_backcolor != value) { + header_backcolor = value; + Refresh (); + } + } + } + + public Font HeaderFont { + get { + return header_font; + } + + set { + if (header_font != null && !header_font.Equals (value)) { + header_font = value; + CalcAreasAndInvalidate (); + } + } + } + + public Color HeaderForeColor { + get { + return header_forecolor; + } + + set { + if (header_forecolor != value) { + header_forecolor = value; + Refresh (); + } + } + } + + protected ScrollBar HorizScrollBar { + get { + return horiz_scrollbar; + } + } + + public object this [DataGridCell cell] { + get { + return this [cell.RowNumber, cell.ColumnNumber]; + } + + set { + this [cell.RowNumber, cell.ColumnNumber] = value; + } + } + + public object this [int rowIndex, int columnIndex] { + get { + return CurrentTableStyle.GridColumnStyles[columnIndex].GetColumnValueAtRow (ListManager, + rowIndex); + } + + set { + CurrentTableStyle.GridColumnStyles[columnIndex].SetColumnValueAtRow (ListManager, + rowIndex, value); + } + } + + public Color LinkColor { + get { + return link_color; + } + set { + if (link_color != value) { + link_color = value; + Refresh (); + } + } + } + + [ComVisible(false)] + [Browsable(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public Color LinkHoverColor { + get { + return link_hovercolor; + } + + set { + if (link_hovercolor != value) { + link_hovercolor = value; + Refresh (); + } + } + } + + [Browsable(false)] + [EditorBrowsable(EditorBrowsableState.Advanced)] + protected internal CurrencyManager ListManager { + get { + if (BindingContext == null || DataSource == null) { + return null; + } + + if (cached_currencymgr != null) { + return cached_currencymgr; + } + + // If we bind real_datasource object we do not get the events from ListManger + // since the object is not the datasource and does not match + cached_currencymgr = (CurrencyManager) BindingContext [real_datasource, DataMember]; + cached_currencymgr_events = (CurrencyManager) BindingContext [datasource, DataMember]; + ConnectListManagerEvents (); + return cached_currencymgr; + } + + set { + throw new NotSupportedException ("Operation is not supported."); + } + } + + public Color ParentRowsBackColor { + get { + return parentrowsback_color; + } + + set { + if (parentrowsback_color != value) { + parentrowsback_color = value; + if (parentrows_visible) { + Refresh (); + } + } + } + } + + public Color ParentRowsForeColor { + get { + return parentrowsfore_color; + } + + set { + if (parentrowsfore_color != value) { + parentrowsfore_color = value; + if (parentrows_visible) { + Refresh (); + } + } + } + } + + [DefaultValue(DataGridParentRowsLabelStyle.Both)] + [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)] + public DataGridParentRowsLabelStyle ParentRowsLabelStyle { + get { + return parentrowslabel_style; + } + + set { + if (parentrowslabel_style != value) { + parentrowslabel_style = value; + if (parentrows_visible) { + Refresh (); + } + + OnParentRowsLabelStyleChanged (EventArgs.Empty); + } + } + } + + [DefaultValue(true)] + public bool ParentRowsVisible { + get { + return parentrows_visible; + } + + set { + if (parentrows_visible != value) { + parentrows_visible = value; + CalcAreasAndInvalidate (); + OnParentRowsVisibleChanged (EventArgs.Empty); + } + } + } + + // Settting this property seems to have no effect. + [DefaultValue(75)] + [TypeConverter(typeof(DataGridPreferredColumnWidthTypeConverter))] + public int PreferredColumnWidth { + get { + return preferredcolumn_width; + } + + set { + if (value < 0) { + throw new ArgumentException ("PreferredColumnWidth is less than 0"); + } + + if (preferredcolumn_width != value) { + preferredcolumn_width = value; + Refresh (); + } + } + } + + public int PreferredRowHeight { + get { + return preferredrow_height; + } + + set { + if (preferredrow_height != value) { + preferredrow_height = value; + CalcAreasAndInvalidate (); + } + } + } + + [DefaultValue(false)] + public bool ReadOnly { + get { + return _readonly; + } + + set { + if (_readonly != value) { + _readonly = value; + OnReadOnlyChanged (EventArgs.Empty); + CalcAreasAndInvalidate (); + } + } + } + + [DefaultValue(true)] + public bool RowHeadersVisible { + get { + return rowheaders_visible; + } + + set { + if (rowheaders_visible != value) { + rowheaders_visible = value; + CalcAreasAndInvalidate (); + } + } + } + + [DefaultValue(35)] + public int RowHeaderWidth { + get { + return rowheaders_width; + } + + set { + if (rowheaders_width != value) { + rowheaders_width = value; + CalcAreasAndInvalidate (); + } + } + } + + public Color SelectionBackColor { + get { + return selection_backcolor; + } + + set { + if (selection_backcolor != value) { + selection_backcolor = value; + Refresh (); + } + } + } + + public Color SelectionForeColor { + get { + return selection_forecolor; + } + + set { + if (selection_forecolor != value) { + selection_forecolor = value; + Refresh (); + } + } + } + + public override ISite Site { + get { + return base.Site; + } + set { + base.Site = value; + } + } + + [Localizable(true)] + [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)] + public GridTableStylesCollection TableStyles { + get { return styles_collection; } + } + + [Bindable(false)] + [Browsable(false)] + [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)] + [EditorBrowsable(EditorBrowsableState.Never)] + public override string Text { + get { + return base.Text; + } + set { + base.Text = value; + } + } + + [Browsable(false)] + [EditorBrowsable(EditorBrowsableState.Advanced)] + protected ScrollBar VertScrollBar { + get { + return vert_scrollbar; + } + } + + [Browsable(false)] + public int VisibleColumnCount { + get { + return visiblecolumn_count; + } + } + + // Calculated at DataGridDrawing.CalcRowsHeaders + [Browsable(false)] + public int VisibleRowCount { + get { + return visiblerow_count; + } + } + + #endregion // Public Instance Properties + + #region Private Instance Properties + internal DataGridTableStyle CurrentTableStyle { + get { + return current_style; + } + set { + current_style = value; + current_style.DataGrid = this; + CalcAreasAndInvalidate (); + } + } + + internal int FirstVisibleRow { + get { return first_visiblerow; } + set { first_visiblerow = value;} + } + + internal int RowsCount { + get { + if (ListManager != null) { + return ListManager.Count; + } + + return 0; + } + } + + internal int RowHeight { + get { + if (CurrentTableStyle.CurrentPreferredRowHeight > Font.Height + 3 + 1 /* line */) { + return CurrentTableStyle.CurrentPreferredRowHeight; + + } else { + return Font.Height + 3 + 1 /* line */; + } + } + } + + internal bool ShowEditRow { + get { + if (ListManager != null && ListManager.CanAddRows == false) { + return false; + } + + return _readonly == false; + } + } + + // It should only be shown if there are relations that + // we do not support right now + internal bool ShowParentRowsVisible { + get { + //See parentrows_visible; + return false; + } + } + + #endregion Private Instance Properties + + #region Public Instance Methods + + [MonoTODO] + public virtual bool BeginEdit (DataGridColumnStyle gridColumn, int rowNumber) + { + return false; + } + + public virtual void BeginInit () + { + begininit = true; + } + + protected virtual void CancelEditing () + { + if (current_cell.ColumnNumber < CurrentTableStyle.GridColumnStyles.Count) { + CurrentTableStyle.GridColumnStyles[current_cell.ColumnNumber].Abort (current_cell.RowNumber); + } + + if (is_adding == true) { + ListManager.RemoveAt (RowsCount - 1); + is_adding = false; + } + + is_editing = false; + is_changing = false; + InvalidateCurrentRowHeader (); + } + + [MonoTODO] + public void Collapse (int row) + { + + } + + protected internal virtual void ColumnStartedEditing (Control editingControl) + { + + } + + protected internal virtual void ColumnStartedEditing (Rectangle bounds) + { + + } + + protected override AccessibleObject CreateAccessibilityInstance () + { + return base.CreateAccessibilityInstance (); + } + + protected virtual DataGridColumnStyle CreateGridColumn (PropertyDescriptor prop) + { + return CreateGridColumn (prop, false); + } + + protected virtual DataGridColumnStyle CreateGridColumn (PropertyDescriptor prop, bool isDefault) + { + throw new NotImplementedException(); + } + + protected override void Dispose (bool disposing) + { + base.Dispose (disposing); + } + + public virtual bool EndEdit (DataGridColumnStyle gridColumn, int rowNumber, bool shouldAbort) + { + if (is_adding == true) { + if (shouldAbort) { + ListManager.CancelCurrentEdit (); + } else { + ListManager.EndCurrentEdit (); + CalcAreasAndInvalidate (); + } + is_adding = false; + } + + if (shouldAbort || gridColumn.ParentReadOnly ==true) { + gridColumn.Abort (rowNumber); + } else { + gridColumn.Commit (ListManager, rowNumber); + } + + is_editing = false; + is_changing = false; + InvalidateCurrentRowHeader (); + return true; + } + + public virtual void EndInit () + { + begininit = false; + } + + public void Expand (int row) + { + + } + + public Rectangle GetCellBounds (DataGridCell cell) + { + return GetCellBounds (cell.RowNumber, cell.ColumnNumber); + } + + public Rectangle GetCellBounds (int row, int col) + { + return grid_drawing.GetCellBounds (row, col); + } + + public Rectangle GetCurrentCellBounds () + { + return GetCellBounds (current_cell.RowNumber, current_cell.ColumnNumber); + } + + protected virtual string GetOutputTextDelimiter () + { + return string.Empty; + } + + protected virtual void GridHScrolled (object sender, ScrollEventArgs se) + { + if (se.NewValue == horz_pixeloffset || + se.Type == ScrollEventType.EndScroll) { + return; + } + + ScrollToColumnInPixels (se.NewValue); + } + + protected virtual void GridVScrolled (object sender, ScrollEventArgs se) + { + int old_first_visiblerow = first_visiblerow; + first_visiblerow = se.NewValue; + grid_drawing.UpdateVisibleRowCount (); + + if (first_visiblerow == old_first_visiblerow) { + return; + } + ScrollToRow (old_first_visiblerow, first_visiblerow); + } + + public HitTestInfo HitTest (Point position) + { + return HitTest (position.X, position.Y); + } + + public HitTestInfo HitTest (int x, int y) + { + return grid_drawing.HitTest (x, y); + } + + [MonoTODO] + public bool IsExpanded (int rowNumber) + { + return false; + } + + public bool IsSelected (int row) + { + return selected_rows[row] != null; + } + + [MonoTODO] + public void NavigateBack () + { + + } + + [MonoTODO] + public void NavigateTo (int rowNumber, string relationName) + { + + } + + protected virtual void OnAllowNavigationChanged (EventArgs e) + { + if (AllowNavigationChanged != null) { + AllowNavigationChanged (this, e); + } + } + + protected void OnBackButtonClicked (object sender, EventArgs e) + { + if (BackButtonClick != null) { + BackButtonClick (sender, e); + } + } + + protected override void OnBackColorChanged (EventArgs e) + { + base.OnBackColorChanged (e); + } + + protected virtual void OnBackgroundColorChanged (EventArgs e) + { + if (BackgroundColorChanged != null) { + BackgroundColorChanged (this, e); + } + } + + protected override void OnBindingContextChanged( EventArgs e) + { + base.OnBindingContextChanged (e); + } + + protected virtual void OnBorderStyleChanged (EventArgs e) + { + if (BorderStyleChanged != null) { + BorderStyleChanged (this, e); + } + } + + protected virtual void OnCaptionVisibleChanged (EventArgs e) + { + if (CaptionVisibleChanged != null) { + CaptionVisibleChanged (this, e); + } + } + + protected virtual void OnCurrentCellChanged (EventArgs e) + { + if (CurrentCellChanged != null) { + CurrentCellChanged (this, e); + } + } + + protected virtual void OnDataSourceChanged (EventArgs e) + { + if (DataSourceChanged != null) { + DataSourceChanged (this, e); + } + } + + protected override void OnEnter (EventArgs e) + { + base.OnEnter (e); + } + + protected virtual void OnFlatModeChanged (EventArgs e) + { + if (FlatModeChanged != null) { + FlatModeChanged (this, e); + } + } + + protected override void OnFontChanged (EventArgs e) + { + grid_drawing.CalcGridAreas (); + base.OnFontChanged (e); + } + + protected override void OnForeColorChanged (EventArgs e) + { + base.OnForeColorChanged (e); + } + + protected override void OnHandleCreated (EventArgs e) + { + base.OnHandleCreated (e); + grid_drawing.CalcGridAreas (); + } + + protected override void OnHandleDestroyed (EventArgs e) + { + base.OnHandleDestroyed (e); + } + + protected override void OnKeyDown (KeyEventArgs ke) + { + base.OnKeyDown (ke); + + if (ProcessGridKey (ke) == true) { + ke.Handled = true; + } + + if (CurrentTableStyle.GridColumnStyles.Count > 0) { + CurrentTableStyle.GridColumnStyles[current_cell.ColumnNumber].OnKeyDown + (ke, current_cell.RowNumber, current_cell.ColumnNumber); + } + } + + protected override void OnKeyPress (KeyPressEventArgs kpe) + { + base.OnKeyPress (kpe); + } + + protected override void OnLayout (LayoutEventArgs levent) + { + base.OnLayout (levent); + CalcAreasAndInvalidate (); + } + + protected override void OnLeave (EventArgs e) + { + base.OnLeave (e); + } + + protected override void OnMouseDown (MouseEventArgs e) + { + base.OnMouseDown (e); + + HitTestInfo testinfo; + testinfo = grid_drawing.HitTest (e.X, e.Y); + + switch (testinfo.type) { + case HitTestType.Cell: + { + if (testinfo.Row < 0 || testinfo.Column < 0) + break; + + DataGridCell new_cell = new DataGridCell (testinfo.Row, testinfo.Column); + + if (new_cell.Equals (current_cell) == false) { + CancelEditing (); + CurrentCell = new_cell; + EditCell (current_cell); + + } else { + CurrentTableStyle.GridColumnStyles[testinfo.Column].OnMouseDown (e, testinfo.Row, testinfo.Column); + } + + break; + } + case HitTestType.RowHeader: + { + if (ctrl_pressed == false && shift_pressed == false) { + ResetSelection (); // Invalidates selected rows + } + + if (shift_pressed == true) { + ShiftSelection (testinfo.Row); + } else { // ctrl_pressed or single item + Select (testinfo.Row); + } + + CancelEditing (); + CurrentCell = new DataGridCell (testinfo.Row, current_cell.ColumnNumber); + OnRowHeaderClick (EventArgs.Empty); + break; + } + + case HitTestType.ColumnHeader: + { + if (CurrentTableStyle.GridColumnStyles.Count == 0) + break; + + if (allow_sorting == false) + break; + + if (ListManager.List is IBindingList == false) + break; + + ListSortDirection direction = ListSortDirection.Ascending; + PropertyDescriptor prop = CurrentTableStyle.GridColumnStyles[testinfo.Column].PropertyDescriptor; + IBindingList list = (IBindingList) ListManager.List; + + if (list.SortProperty != null) { + CurrentTableStyle.GridColumnStyles[list.SortProperty].ArrowDrawingMode + = DataGridColumnStyle.ArrowDrawing.No; + } + + if (prop == list.SortProperty && list.SortDirection == ListSortDirection.Ascending) { + direction = ListSortDirection.Descending; + } + + CurrentTableStyle.GridColumnStyles[testinfo.Column].ArrowDrawingMode = + direction == ListSortDirection.Ascending ? + DataGridColumnStyle.ArrowDrawing.Ascending : DataGridColumnStyle.ArrowDrawing.Descending; + + list.ApplySort (prop, direction); + Refresh (); + break; + } + + default: + break; + } + } + + protected override void OnMouseLeave (EventArgs e) + { + base.OnMouseLeave (e); + } + + protected override void OnMouseMove (MouseEventArgs e) + { + base.OnMouseMove (e); + } + + protected override void OnMouseUp (MouseEventArgs e) + { + base.OnMouseUp (e); + } + + protected override void OnMouseWheel (MouseEventArgs e) + { + base.OnMouseWheel (e); + + if (ctrl_pressed == false) { // scroll horizontal + if (e.Delta > 0) { + if (current_cell.RowNumber > 0) { + CurrentCell = new DataGridCell (current_cell.RowNumber - 1, current_cell.ColumnNumber); + } + } + else { + if (current_cell.RowNumber < RowsCount - 1) { + CurrentCell = new DataGridCell (current_cell.RowNumber + 1, current_cell.ColumnNumber); + } + } + } else { + if (e.Delta > 0) { + if (current_cell.ColumnNumber > 0) { + CurrentCell = new DataGridCell (current_cell.RowNumber, current_cell.ColumnNumber - 1); + } + } + else { + if (current_cell.ColumnNumber < CurrentTableStyle.GridColumnStyles.Count - 1) { + CurrentCell = new DataGridCell (current_cell.RowNumber, current_cell.ColumnNumber + 1); + } + } + } + } + + protected void OnNavigate (NavigateEventArgs e) + { + if (Navigate != null) { + Navigate (this, e); + } + } + + protected override void OnPaint (PaintEventArgs pe) + { + ThemeEngine.Current.DataGridPaint (pe, this); + } + + protected override void OnPaintBackground (PaintEventArgs ebe) + { + } + + protected virtual void OnParentRowsLabelStyleChanged (EventArgs e) + { + if (ParentRowsLabelStyleChanged != null) { + ParentRowsLabelStyleChanged (this, e); + } + } + + protected virtual void OnParentRowsVisibleChanged (EventArgs e) + { + if (ParentRowsVisibleChanged != null) { + ParentRowsVisibleChanged (this, e); + } + } + + protected virtual void OnReadOnlyChanged (EventArgs e) + { + if (ReadOnlyChanged != null) { + ReadOnlyChanged (this, e); + } + } + + protected override void OnResize (EventArgs e) + { + base.OnResize (e); + } + + protected void OnRowHeaderClick (EventArgs e) + { + if (RowHeaderClick != null) { + RowHeaderClick (this, e); + } + } + + protected void OnScroll (EventArgs e) + { + if (Scroll != null) { + Scroll (this, e); + } + } + + protected void OnShowParentDetailsButtonClicked (object sender, EventArgs e) + { + if (ShowParentDetailsButtonClick != null) { + ShowParentDetailsButtonClick (sender, e); + } + } + + protected override bool ProcessDialogKey (Keys keyData) + { + return base.ProcessDialogKey (keyData); + } + + protected bool ProcessGridKey (KeyEventArgs ke) + { + if (RowsCount == 0) { + return false; + } + + switch (ke.KeyCode) { + case Keys.ControlKey: + ctrl_pressed = true; + break; + case Keys.ShiftKey: + shift_pressed = true; + break; + case Keys.Up: + { + if (current_cell.RowNumber > 0) { + CurrentCell = new DataGridCell (current_cell.RowNumber - 1, current_cell.ColumnNumber); + EditCell (current_cell); + } + break; + } + case Keys.Down: + { + if (current_cell.RowNumber < RowsCount - 1) { + CurrentCell = new DataGridCell (current_cell.RowNumber + 1, current_cell.ColumnNumber); + EditCell (current_cell); + } + break; + } + case Keys.Tab: + case Keys.Right: + { + if (current_cell.ColumnNumber + 1 < CurrentTableStyle.GridColumnStyles.Count) { + CurrentCell = new DataGridCell (current_cell.RowNumber, current_cell.ColumnNumber + 1); + EditCell (current_cell); + } + break; + } + case Keys.Left: + { + if (current_cell.ColumnNumber > 0) { + CurrentCell = new DataGridCell (current_cell.RowNumber, current_cell.ColumnNumber - 1); + EditCell (current_cell); + } + break; + } + case Keys.PageUp: + { + if (current_cell.RowNumber > grid_drawing.VLargeChange) { + CurrentCell = new DataGridCell (current_cell.RowNumber - grid_drawing.VLargeChange, current_cell.ColumnNumber); + } else { + CurrentCell = new DataGridCell (0, current_cell.ColumnNumber); + } + + EditCell (current_cell); + break; + } + case Keys.PageDown: + { + if (current_cell.RowNumber + grid_drawing.VLargeChange < RowsCount) { + CurrentCell = new DataGridCell (current_cell.RowNumber + grid_drawing.VLargeChange, current_cell.ColumnNumber); + } else { + CurrentCell = new DataGridCell (RowsCount - 1, current_cell.ColumnNumber); + } + + EditCell (current_cell); + break; + } + case Keys.Home: + { + CurrentCell = new DataGridCell (0, current_cell.ColumnNumber); + EditCell (current_cell); + break; + } + case Keys.End: + { + CurrentCell = new DataGridCell (RowsCount - 1, current_cell.ColumnNumber); + EditCell (current_cell); + break; + } + case Keys.Delete: + { + foreach (int row in selected_rows.Keys) { + ListManager.RemoveAt (row); + } + selected_rows.Clear (); + CalcAreasAndInvalidate (); + break; + } + default: + return false; // message not processed + } + + return true; // message processed + } + + // Called from DataGridTextBox + protected override bool ProcessKeyPreview (ref Message m) + { + Keys key = (Keys) m.WParam.ToInt32 (); + KeyEventArgs ke = new KeyEventArgs (key); + if (ProcessGridKey (ke) == true) { + return true; + } + + return base.ProcessKeyPreview (ref m); + } + + protected bool ProcessTabKey (Keys keyData) + { + return false; + } + + public void ResetAlternatingBackColor () + { + alternating_backcolor = def_alternating_backcolor; + } + + public override void ResetBackColor () + { + backColor = ThemeEngine.Current.DataGridBackColor; + } + + public override void ResetForeColor () + { + base.ResetForeColor (); + } + + public void ResetGridLineColor () + { + gridline_color = def_gridline_color; + } + + public void ResetHeaderBackColor () + { + header_backcolor = def_header_backcolor; + } + + public void ResetHeaderFont () + { + header_font = def_header_font; + } + + public void ResetHeaderForeColor () + { + header_forecolor = def_header_forecolor; + } + + public void ResetLinkColor () + { + link_color = def_link_color; + } + + public void ResetLinkHoverColor () + { + link_hovercolor = def_link_hovercolor; + } + + protected void ResetSelection () + { + foreach (int row in selected_rows.Keys) { + grid_drawing.InvalidateRow (row); + grid_drawing.InvalidateRowHeader (row); + } + + selected_rows.Clear (); + } + + public void ResetSelectionBackColor () + { + selection_backcolor = def_selection_backcolor; + } + + public void ResetSelectionForeColor () + { + selection_forecolor = def_selection_forecolor; + } + + public void Select (int row) + { + if (selected_rows[row] == null) { + selected_rows.Add (row, true); + } else { + selected_rows[row] = true; + } + + grid_drawing.InvalidateRow (row); + } + + public void SetDataBinding (object dataSource, string dataMember) + { + dataMember = null; + SetDataSource (dataSource); + SetDataMember (dataMember); + SetNewDataSource (); + } + + protected virtual bool ShouldSerializeAlternatingBackColor () + { + return (alternating_backcolor != def_alternating_backcolor); + } + + protected virtual bool ShouldSerializeBackgroundColor () + { + return (background_color != def_background_color); + } + + protected virtual bool ShouldSerializeCaptionBackColor () + { + return (caption_backcolor != def_caption_backcolor); + } + + protected virtual bool ShouldSerializeCaptionForeColor () + { + return (caption_forecolor != def_caption_forecolor); + } + + protected virtual bool ShouldSerializeGridLineColor () + { + return (gridline_color != def_gridline_color); + } + + protected virtual bool ShouldSerializeHeaderBackColor () + { + return (header_backcolor != def_header_backcolor); + } + + protected bool ShouldSerializeHeaderFont () + { + return (header_font != def_header_font); + } + + protected virtual bool ShouldSerializeHeaderForeColor () + { + return (header_forecolor != def_header_forecolor); + } + + protected virtual bool ShouldSerializeLinkHoverColor () + { + return (link_hovercolor != def_link_hovercolor); + } + + protected virtual bool ShouldSerializeParentRowsBackColor () + { + return (parentrowsback_color != def_parentrowsback_color); + } + + protected virtual bool ShouldSerializeParentRowsForeColor () + { + return (parentrowsback_color != def_parentrowsback_color); + } + + protected bool ShouldSerializePreferredRowHeight () + { + return (preferredrow_height != def_preferredrow_height); + } + + protected bool ShouldSerializeSelectionBackColor () + { + return (selection_backcolor != def_selection_backcolor); + } + + protected virtual bool ShouldSerializeSelectionForeColor () + { + return (selection_forecolor != def_selection_forecolor); + } + + public void SubObjectsSiteChange (bool site) + { + + } + + public void UnSelect (int row) + { + selected_rows.Remove (row); + grid_drawing.InvalidateRow (row); + + } + #endregion // Public Instance Methods + + #region Private Instance Methods + + internal void CalcAreasAndInvalidate () + { + grid_drawing.CalcGridAreas (); + Invalidate (); + } + + private void ConnectListManagerEvents () + { + cached_currencymgr_events.CurrentChanged += new EventHandler (OnListManagerCurrentChanged); + } + + private void DisconnectListManagerEvents () + { + + } + + // EndEdit current editing operation + internal virtual bool EndEdit (bool shouldAbort) + { + return EndEdit (CurrentTableStyle.GridColumnStyles[current_cell.ColumnNumber], + current_cell.RowNumber, shouldAbort); + } + + private void EnsureCellVisilibility (DataGridCell cell) + { + if (cell.ColumnNumber <= first_visiblecolumn || + cell.ColumnNumber + 1 >= first_visiblecolumn + visiblecolumn_count) { + + first_visiblecolumn = grid_drawing.GetFirstColumnForColumnVisilibility (first_visiblecolumn, cell.ColumnNumber); + + int pixel = grid_drawing.GetColumnStartingPixel (first_visiblecolumn); + ScrollToColumnInPixels (pixel); + } + + if (cell.RowNumber < first_visiblerow || + cell.RowNumber + 1 >= first_visiblerow + visiblerow_count) { + + if (cell.RowNumber + 1 >= first_visiblerow + visiblerow_count) { + int old_first_visiblerow = first_visiblerow; + first_visiblerow = 1 + cell.RowNumber - visiblerow_count; + grid_drawing.UpdateVisibleRowCount (); + ScrollToRow (old_first_visiblerow, first_visiblerow); + }else { + int old_first_visiblerow = first_visiblerow; + first_visiblerow = cell.RowNumber; + grid_drawing.UpdateVisibleRowCount (); + ScrollToRow (old_first_visiblerow, first_visiblerow); + } + + vert_scrollbar.Value = first_visiblerow; + } + } + + internal IEnumerable GetDataSource (object source, string member) + { + IListSource src = (IListSource) source; + IList list = src.GetList(); + IListSource listsource; + ITypedList typedlist; + + if (source is IEnumerable) { + return (IEnumerable) source; + } + + if(src.ContainsListCollection == false) { + return list; + } + + listsource = (IListSource) source; + + if (listsource == null) { + return null; + } + + list = src.GetList (); + + if (list == null) { + return null; + } + + typedlist = (ITypedList) list; + + if (typedlist == null) { + return null; + } + + PropertyDescriptorCollection col = typedlist.GetItemProperties (new PropertyDescriptor [0]); + PropertyDescriptor prop = col.Find (member, true); + + if (prop == null) { + if (col.Count > 0) { + prop = col[0]; + + if (prop == null) { + return null; + } + } + } + + IEnumerable result = (IEnumerable)(prop.GetValue (list[0])); + return result; + + } + + internal void InvalidateCurrentRowHeader () + { + grid_drawing.InvalidateRowHeader (current_cell.RowNumber); + } + + private bool SetDataMember (string member) + { + if (member == datamember) { + return false; + } + + datamember = member; + real_datasource = GetDataSource (datasource, member); + DisconnectListManagerEvents (); + cached_currencymgr = cached_currencymgr_events = null; + return true; + } + + private bool SetDataSource (object source) + { + + if (source != null && source as IListSource != null && source as IList != null) { + throw new Exception ("Wrong complex data binding source"); + } + + current_cell = new DataGridCell (); + datasource = source; + DisconnectListManagerEvents (); + cached_currencymgr = cached_currencymgr_events = null; + try { + real_datasource = GetDataSource (datasource, DataMember); + }catch (Exception e) { + real_datasource = source; + } + + OnDataSourceChanged (EventArgs.Empty); + return true; + } + + private void SetNewDataSource () + { + if (ListManager != null && TableStyles[datamember] == null) { + current_style.GridColumnStyles.Clear (); + } + current_style.CreateColumnsForTable (false); + CalcAreasAndInvalidate (); + } + + private void OnKeyUpDG (object sender, KeyEventArgs e) + { + switch (e.KeyCode) { + case Keys.ControlKey: + ctrl_pressed = false; + break; + case Keys.ShiftKey: + shift_pressed = false; + break; + default: + break; + } + } + + private void OnListManagerCurrentChanged (object sender, EventArgs e) + { + if (accept_listmgrevents == false) { + return; + } + + CurrentCell = new DataGridCell (cached_currencymgr_events.Position, current_cell.RowNumber); + } + + private void OnTableStylesCollectionChanged (object sender, CollectionChangeEventArgs e) + { + if (ListManager == null) + return; + + switch (e.Action){ + case CollectionChangeAction.Add: { + if (e.Element != null && String.Compare (ListManager.ListName, ((DataGridTableStyle)e.Element).MappingName, true) == 0) { + CurrentTableStyle = (DataGridTableStyle)e.Element; + ((DataGridTableStyle) e.Element).CreateColumnsForTable (false); + } + break; + } + + case CollectionChangeAction.Remove: { + if (e.Element != null && String.Compare (ListManager.ListName, ((DataGridTableStyle)e.Element).MappingName, true) == 0) { + CurrentTableStyle = default_style; + current_style.GridColumnStyles.Clear (); + current_style.CreateColumnsForTable (false); + } + break; + } + + + case CollectionChangeAction.Refresh: { + if (e.Element != null && String.Compare (ListManager.ListName, ((DataGridTableStyle)e.Element).MappingName, true) == 0) { + CurrentTableStyle = (DataGridTableStyle)e.Element; + ((DataGridTableStyle) e.Element).CreateColumnsForTable (false); + } else { + CurrentTableStyle = default_style; + current_style.GridColumnStyles.Clear (); + current_style.CreateColumnsForTable (false); + + } + break; + + } + } + CalcAreasAndInvalidate (); + } + + private void EditCell (DataGridCell cell) + { + ResetSelection (); // Invalidates selected rows + is_editing = false; + is_changing = false; + + if (ShowEditRow && is_adding == false && cell.RowNumber >= RowsCount) { + ListManager.AddNew (); + is_adding = true; + Invalidate (); // We have just added a new row + } + + CurrentTableStyle.GridColumnStyles[cell.ColumnNumber].Edit (ListManager, + cell.RowNumber, GetCellBounds (cell.RowNumber, cell.ColumnNumber), + _readonly, string.Empty, true); + } + + private void ShiftSelection (int index) + { + int shorter_item = -1, dist = RowsCount + 1, cur_dist; + + foreach (int row in selected_rows.Keys) { + + if (row > index) { + cur_dist = row - index; + } + else { + cur_dist = index - row; + } + + if (cur_dist < dist) { + dist = cur_dist; + shorter_item = row; + } + } + + if (shorter_item != -1) { + int start, end; + + if (shorter_item > index) { + start = index; + end = shorter_item; + } else { + start = shorter_item; + end = index; + } + + ResetSelection (); + for (int idx = start; idx <= end; idx++) { + Select (idx); + } + } + } + + private void ScrollToColumnInPixels (int pixel) + { + Rectangle invalidate = new Rectangle (); + Rectangle invalidate_column = new Rectangle (); + + if (pixel > horz_pixeloffset) { // ScrollRight + int pixels = pixel - horz_pixeloffset; + + horz_pixeloffset = horiz_scrollbar.Value = pixel; + grid_drawing.UpdateVisibleColumn (); + + // Columns header + invalidate_column.X = grid_drawing.ColumnsHeadersArea.X + grid_drawing.ColumnsHeadersArea.Width - pixels; + invalidate_column.Y = grid_drawing.ColumnsHeadersArea.Y; + invalidate_column.Width = pixels; + invalidate_column.Height = grid_drawing.ColumnsHeadersArea.Height; + XplatUI.ScrollWindow (Handle, grid_drawing.ColumnsHeadersArea, -pixels, 0, false); + + // Cells + invalidate.X = grid_drawing.CellsArea.X + grid_drawing.CellsArea.Width - pixels; + invalidate.Y = grid_drawing.CellsArea.Y; + invalidate.Width = pixels; + invalidate.Height = grid_drawing.CellsArea.Height; + + + if (columnheaders_visible == true) { + invalidate.Y -= grid_drawing.ColumnsHeadersArea.Height; + invalidate.Height += grid_drawing.ColumnsHeadersArea.Height; + } + + XplatUI.ScrollWindow (Handle, grid_drawing.CellsArea, -pixels, 0, false); + Invalidate (invalidate_column); + Invalidate (invalidate); + + + } else { + int pixels = horz_pixeloffset - pixel; + Rectangle area = grid_drawing.CellsArea; + + horz_pixeloffset = horiz_scrollbar.Value = pixel; + grid_drawing.UpdateVisibleColumn (); + + // Columns header + invalidate_column.X = grid_drawing.ColumnsHeadersArea.X; + invalidate_column.Y = grid_drawing.ColumnsHeadersArea.Y; + invalidate_column.Width = pixels; + invalidate_column.Height = grid_drawing.ColumnsHeadersArea.Height; + //XplatUI.ScrollWindow (Handle, grid_drawing.ColumnsHeadersArea, pixels, 0, false); + + // Cells + invalidate.X = grid_drawing.CellsArea.X; + invalidate.Y = grid_drawing.CellsArea.Y; + invalidate.Width = pixels; + invalidate.Height = grid_drawing.CellsArea.Height; + + if (columnheaders_visible == true) { + invalidate.Y -= grid_drawing.ColumnsHeadersArea.Height; + invalidate.Height += grid_drawing.ColumnsHeadersArea.Height; + area.Y -= grid_drawing.ColumnsHeadersArea.Height; + area.Height += grid_drawing.ColumnsHeadersArea.Height; + } + + XplatUI.ScrollWindow (Handle, area, pixels, 0, false); + Invalidate (invalidate); + } + + } + + private void ScrollToRow (int old_row, int new_row) + { + Rectangle invalidate = new Rectangle (); + + if (new_row > old_row) { // Scrolldown + int scrolled_rows = new_row - old_row; + int pixels = scrolled_rows * RowHeight; + Rectangle rows_area = grid_drawing.CellsArea; // Cells area - partial rows space + rows_area.Height = grid_drawing.CellsArea.Height - grid_drawing.CellsArea.Height % RowHeight; + + invalidate.X = grid_drawing.CellsArea.X; + invalidate.Y = grid_drawing.CellsArea.Y + rows_area.Height - pixels; + invalidate.Width = grid_drawing.CellsArea.Width; + invalidate.Height = pixels; + + XplatUI.ScrollWindow (Handle, rows_area, 0, -pixels, false); + + } else { // ScrollUp + int scrolled_rows = old_row - new_row; + int pixels = scrolled_rows * RowHeight; + + invalidate.X = grid_drawing.CellsArea.X; + invalidate.Y = grid_drawing.CellsArea.Y; + invalidate.Width = grid_drawing.CellsArea.Width; + invalidate.Height = pixels; + XplatUI.ScrollWindow (Handle, grid_drawing.CellsArea, 0, pixels, false); + } + + // Right now we use ScrollWindow Invalidate, let's leave remarked it here for X11 if need it + //Invalidate (invalidate); + Invalidate (grid_drawing.RowsHeadersArea); + } + + #endregion Private Instance Methods + + + #region Events + public event EventHandler AllowNavigationChanged; + public event EventHandler BackButtonClick; + public event EventHandler BackgroundColorChanged; + + [Browsable(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public new event EventHandler BackgroundImageChanged; + + public event EventHandler BorderStyleChanged; + public event EventHandler CaptionVisibleChanged; + public event EventHandler CurrentCellChanged; + + [Browsable(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public new event EventHandler CursorChanged; + + public event EventHandler DataSourceChanged; + public event EventHandler FlatModeChanged; + public event NavigateEventHandler Navigate; + public event EventHandler ParentRowsLabelStyleChanged; + public event EventHandler ParentRowsVisibleChanged; + public event EventHandler ReadOnlyChanged; + protected event EventHandler RowHeaderClick; + public event EventHandler Scroll; + public event EventHandler ShowParentDetailsButtonClick; + + [Browsable(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public new event EventHandler TextChanged; + #endregion // Events + } +} |