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;
internal int visiblecolumn_count;
internal int visiblerow_count;
internal int first_visiblecolumn;
- private int currentrow_index;
private GridTableStylesCollection styles_collection;
private DataGridParentRowsLabelStyle parentrowslabel_style;
internal DataGridCell current_cell;
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)
+ private Hashtable selected_rows;
+ private bool ctrl_pressed;
+ private bool shift_pressed;
#endregion // Local Variables
#region Public Constructors
parentrowsfore_color = def_parentrowsfore_color;
parentrows_visible = false; // should be true (temp)
preferredcolumn_width = ThemeEngine.Current.DataGridPreferredColumnWidth;
- preferredrow_height = 16;
- _readonly = false ;
+ _readonly = false;
rowheaders_visible = true;
selection_backcolor = def_selection_backcolor;
selection_forecolor = def_selection_forecolor;
visiblecolumn_count = 0;
visiblerow_count = 0;
current_cell = new DataGridCell ();
- currentrow_index = -1;
first_visiblerow = 0;
first_visiblecolumn = 0;
horz_pixeloffset = 0;
forecolor = SystemColors.WindowText;
parentrowslabel_style = DataGridParentRowsLabelStyle.Both;
backcolor = SystemColors.Window;
+ selected_rows = new Hashtable ();
+ ctrl_pressed = false;
+ shift_pressed = false;
+ preferredrow_height = def_preferredrow_height = FontHeight + 3;
default_style = new DataGridTableStyle (true);
styles_collection = new GridTableStylesCollection (this);
vert_scrollbar = new VScrollBar ();
vert_scrollbar.Scroll += new ScrollEventHandler (GridVScrolled);
grid_drawing = new DataGridDrawing (this);
+ KeyUp += new KeyEventHandler (OnKeyUpDG);
+ HandleCreated += new EventHandler (OnCreateHandle);
SetStyle (ControlStyles.UserPaint | ControlStyles.AllPaintingInWmPaint, true);
set {
if (!current_cell.Equals (value)) {
- grid_drawing.InvalidateRowHeader (current_cell.RowNumber); // old row header
+ CancelEditing ();
+ EnsureCellVisilibility (value);
current_cell = value;
- InvalidateCurrentRowHeader ();
+ OnCurrentCellChanged (EventArgs.Empty);
}
}
}
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public int CurrentRowIndex {
get {
- return currentrow_index;
+ return current_cell.RowNumber;
}
set {
- if (currentrow_index != value) {
- currentrow_index = value;
- Refresh ();
+ if (current_cell.RowNumber != value) {
+ CurrentCell = new DataGridCell (value, current_cell.ColumnNumber);
}
}
}
internal int RowHeight {
get {
- if (preferredrow_height > Font.Height + 3) {
+ if (preferredrow_height > Font.Height + 3 + 1 /* line */) {
return preferredrow_height;
} else {
- return Font.Height + 3;
+ return Font.Height + 3 + 1 /* line */;
}
}
}
protected virtual void CancelEditing ()
- {
- if (is_editing == false) {
- return;
- }
-
+ {
CurrentTableStyle.GridColumnStyles[current_cell.ColumnNumber].Abort (current_cell.RowNumber);
is_editing = false;
is_changing = false;
if (is_editing == false) {
return false;
}
-
+
if (shouldAbort) {
gridColumn.Abort (rowNumber);
} else {
gridColumn.Commit (ListManager, rowNumber);
}
-
+
is_editing = false;
is_changing = false;
InvalidateCurrentRowHeader ();
return;
}
- Rectangle invalidate = new Rectangle ();
- Rectangle invalidate_column = new Rectangle ();
-
- if (se.NewValue > horz_pixeloffset) { // ScrollRight
- int pixels = se.NewValue - horz_pixeloffset;
-
- // 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;
- XplatUI.ScrollWindow (Handle, grid_drawing.CellsArea, -pixels, 0, false);
-
- } else {
- int pixels = horz_pixeloffset - se.NewValue;
-
- // 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;
- XplatUI.ScrollWindow (Handle, grid_drawing.CellsArea, pixels, 0, false);
- }
-
- horz_pixeloffset = se.NewValue;
- grid_drawing.UpdateVisibleColumn ();
- Invalidate (invalidate_column);
- Invalidate (invalidate);
+ 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;
}
-
- Rectangle invalidate = new Rectangle ();
-
- if (se.NewValue > old_first_visiblerow ) { // Scrolldown
- int scrolled_rows = se.NewValue - old_first_visiblerow;
- int pixels = scrolled_rows * RowHeight;
-
- invalidate.X = grid_drawing.CellsArea.X;
- invalidate.Y = grid_drawing.CellsArea.Y + grid_drawing.CellsArea.Height - pixels;
- invalidate.Width = grid_drawing.CellsArea.Width;
- invalidate.Height = pixels;
-
- XplatUI.ScrollWindow (Handle, grid_drawing.CellsArea, 0, -pixels, false);
-
- } else { // ScrollUp
- int scrolled_rows = old_first_visiblerow - se.NewValue;
- 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);
- }
-
- Invalidate (invalidate);
- Invalidate (grid_drawing.RowsHeadersArea);
+ ScrollToRow (old_first_visiblerow, first_visiblerow);
}
public HitTestInfo HitTest (Point position)
public bool IsSelected (int row)
{
- throw new NotImplementedException ();
+ return selected_rows[row] != null;
}
public void NavigateBack ()
protected override void OnKeyDown (KeyEventArgs ke)
{
base.OnKeyDown (ke);
- CurrentTableStyle.GridColumnStyles[current_cell.ColumnNumber].OnKeyDown
+
+ if (KeyboardNavigation (ke.KeyCode) == true) {
+ ke.Handled = true;
+ }
+
+ CurrentTableStyle.GridColumnStyles[current_cell.ColumnNumber].OnKeyDown
(ke, current_cell.RowNumber, current_cell.ColumnNumber);
}
protected override void OnKeyPress (KeyPressEventArgs kpe)
- {
+ {\r
base.OnKeyPress (kpe);
}
HitTestInfo testinfo;
testinfo = grid_drawing.HitTest (e.X, e.Y);
- if (testinfo.type == HitTestType.Cell) {
-
+ switch (testinfo.type) {
+ case HitTestType.Cell:
+ {
DataGridCell new_cell = new DataGridCell (testinfo.Row, testinfo.Column);
-
+
if (new_cell.Equals (current_cell) == false) {
CancelEditing ();
CurrentCell = new_cell;
- is_editing = true;
- is_changing = false;
- CurrentTableStyle.GridColumnStyles[testinfo.Column].Edit (ListManager,
- testinfo.Row, GetCellBounds (testinfo.Row, testinfo.Column),
- _readonly, string.Empty, true);
- } else {
+ 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;
+ }
+ default:
+ break;
}
}
protected override void OnMouseWheel (MouseEventArgs e)
{
base.OnMouseWheel (e);
+
+ 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);
+ }
+ }
}
protected void OnNavigate (NavigateEventArgs e)
throw new NotImplementedException ();
}
+ // Called from DataGridTextBox
protected override bool ProcessKeyPreview (ref Message m)
{
+ Keys key = (Keys) m.WParam.ToInt32 ();
+ if (KeyboardNavigation (key) == true) {
+ return true;
+ }
+
return base.ProcessKeyPreview (ref m);
}
protected void ResetSelection ()
{
+ ICollection keys = selected_rows.Keys;
+ foreach (int row in selected_rows.Keys) {
+ grid_drawing.InvalidateRow (row);
+ grid_drawing.InvalidateRowHeader (row);
+ }
+ selected_rows.Clear ();
}
public void ResetSelectionBackColor ()
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)
protected bool ShouldSerializePreferredRowHeight ()
{
- return (parentrowsfore_color != def_parentrowsfore_color);
+ return (preferredrow_height != def_preferredrow_height);
}
protected bool ShouldSerializeSelectionBackColor ()
public void UnSelect (int row)
{
+ selected_rows.Remove (row);
+ grid_drawing.InvalidateRow (row);
}
#endregion // Public Instance Methods
Invalidate ();
}
+ internal bool KeyboardNavigation (Keys key)
+ {
+ if (RowsCount == 0) {
+ return false;
+ }
+
+ switch (key) {
+ 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.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:
+ {
+ ICollection keys = selected_rows.Keys;
+ 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
+ }
+
// EndEdit current editing operation
public virtual bool EndEdit (bool shouldAbort)
- {
- return EndEdit (CurrentTableStyle.GridColumnStyles[current_cell.ColumnNumber],
+ {
+ return EndEdit (CurrentTableStyle.GridColumnStyles[current_cell.ColumnNumber],
current_cell.RowNumber, shouldAbort);
}
+ private void EnsureCellVisilibility (DataGridCell cell)
+ {
+ if (current_cell.RowNumber != cell.RowNumber) {
+ grid_drawing.InvalidateRowHeader (current_cell.RowNumber);
+ grid_drawing.InvalidateRowHeader (cell.RowNumber);
+ }
+
+ if (cell.ColumnNumber < first_visiblecolumn ||
+ cell.ColumnNumber >= first_visiblecolumn + visiblecolumn_count) {
+
+ int col, pixel;
+
+ if (cell.ColumnNumber + 1 >= first_visiblecolumn + visiblecolumn_count) {
+ col = 1 + cell.ColumnNumber - visiblecolumn_count;
+ }else {
+ col = cell.RowNumber;
+ }
+
+ pixel = grid_drawing.GetColumnStartingPixel (col);
+ 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 void InvalidateCurrentRowHeader ()
{
grid_drawing.InvalidateRowHeader (current_cell.RowNumber);
datamember = "";
real_datasource = source;
}
-
+
OnDataSourceChanged (EventArgs.Empty);
return true;
}
grid_drawing.CalcGridAreas ();
}
+ 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 OnCreateHandle (object sender, EventArgs e)
+ {
+ Console.WriteLine ("OnCreateHandle");
+ }
+
private void OnTableStylesCollectionChanged (object sender, CollectionChangeEventArgs e)
{
Console.WriteLine ("Datagrid.TableStyles Collection Changed {0}, null {1}", e.Action,
}
}
+
+ private void EditCell (DataGridCell cell)
+ {
+ ResetSelection (); // Invalidates selected rows
+ is_editing = false;
+ is_changing = false;
+ 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;
+ ICollection keys = selected_rows.Keys;
+
+ 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;
+
+ // 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;
+ XplatUI.ScrollWindow (Handle, grid_drawing.CellsArea, -pixels, 0, false);
+
+ } else {
+ int pixels = horz_pixeloffset - pixel;
+
+ // 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;
+ XplatUI.ScrollWindow (Handle, grid_drawing.CellsArea, pixels, 0, false);
+ }
+
+ horz_pixeloffset = horiz_scrollbar.Value = pixel;
+ grid_drawing.UpdateVisibleColumn ();
+ Invalidate (invalidate_column);
+ 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;
+
+ invalidate.X = grid_drawing.CellsArea.X;
+ invalidate.Y = grid_drawing.CellsArea.Y + grid_drawing.CellsArea.Height - pixels;
+ invalidate.Width = grid_drawing.CellsArea.Width;
+ invalidate.Height = pixels;
+
+ XplatUI.ScrollWindow (Handle, grid_drawing.CellsArea, 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 (grid_drawing.RowsHeadersArea);
+ }
+
#endregion Private Instance Methods
private Rectangle rowshdrs_area; // Used Headers rows area
private int rowshdrs_maxheight; // Total height for rows (max height)
private Rectangle cells_area;
+ private bool partial_row;
#endregion // Local Variables
client_area.Width -= BorderStyleSize * 2;
client_area.Height -= BorderStyleSize * 2;
+ Console.WriteLine ("CalcClientArea");
+
//Console.WriteLine ("CalcClientArea ClientRectangle {0}, ClientArea {1}, BorderStyleSize {2}",
// grid.ClientRectangle, client_area, BorderStyleSize);
}
CalcColumnsHeader ();
CalcCellsArea ();
+ UpdateVisibleRowCount (); // need it to be able to calcultate the need of horz scrollbar
if (SetUpVerticalScrollBar ()) { // We need a Vertical ScrollBar
if (grid.caption_visible) {
caption_area.Width -= grid.vert_scrollbar.Width;
}
UpdateVisibleColumn ();
+ UpdateVisibleRowCount ();
//Console.WriteLine ("DataGridDrawing.CalcGridAreas cells:{0}", cells_area);
}
return;
}
- UpdateVisibleRowCount ();
-
if (grid.caption_visible) {
rowshdrs_area.Y = caption_area.Y + caption_area.Height;
} else {
public void UpdateVisibleRowCount ()
{
- int max_height = client_area.Height - caption_area.Height -
- parent_rows.Height - columnshdrs_area.Height;
+ int max_height = cells_area.Height;
int rows_height = (grid.RowsCount - grid.first_visiblerow) * grid.RowHeight;
int max_rows = max_height / grid.RowHeight;
-
+
+ //Console.WriteLine ("UpdateVisibleRowCount {0} {1}/{2} (row h) {3}",
+ // max_rows, max_height, grid.RowHeight, cells_area.Height);
+
if (max_rows > grid.RowsCount) {
max_rows = grid.RowsCount;
}
if (rows_height > cells_area.Height) {
- grid.visiblerow_count = max_height / grid.RowHeight;
+ grid.visiblerow_count = max_rows;
} else {
grid.visiblerow_count = grid.RowsCount;
}
if (grid.visiblerow_count + grid.first_visiblerow > grid.RowsCount)
grid.visiblerow_count = grid.RowsCount - grid.first_visiblerow;
-
+
if (grid.visiblerow_count < max_rows) {
grid.visiblerow_count = max_rows;
grid.first_visiblerow = grid.RowsCount - max_rows;
grid.Invalidate ();
}
+
+ // TODO: Partial visible rows? May be only paint them and not take then into account for any
+ // anything else
+ //grid.visiblerow_count++;
}
// From Point to Cell
if (rowshdrs_area.Contains (x, y)) {
hit.type = DataGrid.HitTestType.RowHeader;
+ int posy;
+ int rcnt = grid.FirstVisibleRow + grid.VisibleRowCount;
+ for (int r = grid.FirstVisibleRow; r < rcnt; r++) {
+ posy = cells_area.Y + ((r - grid.FirstVisibleRow) * grid.RowHeight);
+ if (y <= posy + grid.RowHeight) { // Found row
+ hit.row = r;
+ break;
+ }
+ }
return hit;
}
public void OnPaint (PaintEventArgs pe)
{
+ Console.WriteLine ("OnPaint {0}", pe.ClipRectangle);
ThemeEngine.Current.CPDrawBorderStyle (pe.Graphics, grid.ClientRectangle, grid.border_style);
if (pe.ClipRectangle.IntersectsWith (parent_rows)) {
not_usedarea.Intersect (rowshdrs_area_complete);
int rowcnt = grid.FirstVisibleRow + grid.VisibleRowCount;
+
+ if (rowcnt < grid.RowsCount) { // Paint one row more for partial rows
+ rowcnt++;
+ }
+
for (int row = grid.FirstVisibleRow; row < rowcnt; row++) {
rect_row.Width = rowshdrs_area.Width;
not_usedarea.Dispose ();
}
+ public void InvalidateRow (int row)
+ {
+ if (row < grid.FirstVisibleRow || row > grid.FirstVisibleRow + grid.VisibleRowCount) {
+ return;
+ }
+
+ Rectangle rect_row = new Rectangle ();
+
+ rect_row.X = cells_area.X;
+ rect_row.Width = cells_area.Width;
+ rect_row.Height = grid.RowHeight;
+ rect_row.Y = cells_area.Y + ((row - grid.FirstVisibleRow) * grid.RowHeight);
+ grid.Invalidate (rect_row);
+ }
+
public void InvalidateRowHeader (int row)
{
Rectangle rect_rowhdr = new Rectangle ();
not_usedarea.Intersect (cells_area);
int rowcnt = grid.FirstVisibleRow + grid.VisibleRowCount;
+
+ if (rowcnt < grid.RowsCount) { // Paint one row more for partial rows
+ rowcnt++;
+ }
+
for (int row = grid.FirstVisibleRow; row < rowcnt; row++) {
// Get cell's width for column style
rect_row.Width = cells.Width;
public void PaintRow (Graphics g, int row, Rectangle row_rect)
{
- //Console.WriteLine ("PaintRow row: {0}, rect {1}", row, row_rect);
+ Console.WriteLine ("PaintRow row: {0}, rect {1}", row, row_rect);
Rectangle rect_cell = new Rectangle ();
int cnt = grid.CurrentTableStyle.GridColumnStyles.Count;
int col_pixel;
+ Color backcolor, forecolor;
Region prev_clip = g.Clip;
Region current_clip;
Region not_usedarea = new Region (row_rect);
current_clip = new Region (row_rect);
g.Clip = current_clip;
- g.FillRectangle (ThemeEngine.Current.ResPool.GetSolidBrush (grid.BackgroundColor), rect_cell);
- g.DrawRectangle (ThemeEngine.Current.ResPool.GetPen (ThemeEngine.Current.ColorButtonShadow), rect_cell);
+ if (grid.IsSelected (row)) {
+ backcolor = grid.SelectionBackColor;
+ forecolor = grid.SelectionForeColor;
+ } else {
+ backcolor = grid.BackgroundColor;
+ forecolor = grid.ForeColor;
+ }
not_usedarea.Exclude (rect_cell);
- grid.CurrentTableStyle.GridColumnStyles[column].Paint (g, rect_cell, grid.ListManager, row);
+
+ grid.CurrentTableStyle.GridColumnStyles[column].Paint (g, rect_cell, grid.ListManager, row,
+ ThemeEngine.Current.ResPool.GetSolidBrush (backcolor),
+ ThemeEngine.Current.ResPool.GetSolidBrush (forecolor),
+ grid.RightToLeft == RightToLeft.Yes);
g.Clip = prev_clip;
current_clip.Dispose ();
grid.horiz_scrollbar.Size = new Size (client_area.Width,
grid.horiz_scrollbar.Height);
- //grid.horiz_scrollbar.Maximum = width_all - cells_area.Width;
- //grid.horiz_scrollbar.LargeChange = cells_area.Width;
+ grid.horiz_scrollbar.Maximum = width_all - cells_area.Width;
+ grid.horiz_scrollbar.LargeChange = cells_area.Width;
grid.Controls.Add (grid.horiz_scrollbar);
grid.horiz_scrollbar.Visible = true;
return true;
client_area.Height);
grid.vert_scrollbar.Maximum = grid.RowsCount;
- grid.vert_scrollbar.LargeChange = cells_area.Height / grid.RowHeight;
+ grid.vert_scrollbar.LargeChange = VLargeChange;
grid.Controls.Add (grid.vert_scrollbar);
grid.vert_scrollbar.Visible = true;
}
}
+ public int VLargeChange {
+ get {
+ return cells_area.Height / grid.RowHeight;
+ }
+ }
+
#endregion Instance Properties
}
}
projects / mono.git / commitdiff