public ScrollCommand(GridUpdateType code, Size size)
{
Debug.Assert(code == GridUpdateType.SizeChange);
UpdateType = code;
Param = size;
}
private async Task DrawVisualsAsync(GridUpdateType updateType, bool suppressNotification, CancellationToken token, ISortOrder sortOrder)
{
var visualViewport = new Rect(Points.HorizontalOffset, Points.VerticalOffset, Points.ViewportWidth, Points.ViewportHeight);
var newViewport = Points.ComputeDataViewport(visualViewport);
if (newViewport.Rows.Count < 1 || newViewport.Columns.Count < 1)
{
return;
}
// pull data from provider
try {
var data = await DataProvider.GetAsync(newViewport, sortOrder);
if (data == null)
{
throw new InvalidOperationException("Couldn't fetch grid data");
}
if (!data.Grid.Range.Contains(newViewport) ||
!data.ColumnHeader.Range.Contains(newViewport.Columns) ||
!data.RowHeader.Range.Contains(newViewport.Rows))
{
throw new InvalidOperationException("Couldn't acquire enough data");
}
await DrawVisualsAsync(newViewport, data, updateType, visualViewport, suppressNotification, token);
} catch (OperationCanceledException) { }
}
private async Task DrawVisualsAsync(GridUpdateType updateType, bool suppressNotification, CancellationToken token, ISortOrder sortOrder)
{
Rect visualViewport = new Rect(
Points.HorizontalOffset,
Points.VerticalOffset,
Points.ViewportWidth,
Points.ViewportHeight);
GridRange newViewport = Points.ComputeDataViewport(visualViewport);
if (newViewport.Rows.Count < 1 || newViewport.Columns.Count < 1)
{
return;
}
// pull data from provider
try {
var data = await DataProvider.GetAsync(newViewport, sortOrder);
if (!data.Grid.Range.Contains(newViewport) ||
!data.ColumnHeader.Range.Contains(newViewport.Columns) ||
!data.RowHeader.Range.Contains(newViewport.Rows))
{
throw new InvalidOperationException("Couldn't acquire enough data");
}
// actual drawing runs in UI thread
await Task.Factory.StartNew(
() => DrawVisuals(newViewport, data, updateType, visualViewport, suppressNotification),
token,
TaskCreationOptions.None,
_ui);
} catch (OperationCanceledException) { }
}
public ScrollCommand(GridUpdateType code, double offset, ThumbTrack thumbtrack) {
Debug.Assert(code == GridUpdateType.SetHorizontalOffset
|| code == GridUpdateType.SetVerticalOffset);
UpdateType = code;
Param = new Tuple<double, ThumbTrack>(offset, thumbtrack);
}
public ScrollCommand(GridUpdateType code, double param) {
Debug.Assert(code != GridUpdateType.SizeChange
&& code != GridUpdateType.SetHorizontalOffset
&& code != GridUpdateType.SetVerticalOffset);
UpdateType = code;
Param = param;
}
public ScrollCommand(GridUpdateType code, double offset, ThumbTrack thumbtrack)
{
Debug.Assert(code == GridUpdateType.SetHorizontalOffset ||
code == GridUpdateType.SetVerticalOffset);
UpdateType = code;
Param = new Tuple <double, ThumbTrack>(offset, thumbtrack);
}
public ScrollCommand(GridUpdateType code, double param)
{
Debug.Assert(code != GridUpdateType.SizeChange &&
code != GridUpdateType.SetHorizontalOffset &&
code != GridUpdateType.SetVerticalOffset);
UpdateType = code;
Param = param;
}
private async Task DrawVisualsAsync(
GridRange dataViewport,
IGridData <string> data,
GridUpdateType updateType,
Rect visualViewport,
bool suppressNotification,
CancellationToken token)
{
await VsAppShell.Current.SwitchToMainThreadAsync(token);
using (var deferal = Points.DeferChangeNotification(suppressNotification)) {
// measure points
ColumnHeader?.MeasurePoints(
Points.GetAccessToPoints(ColumnHeader.ScrollDirection),
new GridRange(new Range(0, 1), dataViewport.Columns),
new RangeToGrid <string>(dataViewport.Columns, data.ColumnHeader, true),
updateType);
RowHeader?.MeasurePoints(
Points.GetAccessToPoints(RowHeader.ScrollDirection),
new GridRange(dataViewport.Rows, new Range(0, 1)),
new RangeToGrid <string>(dataViewport.Rows, data.RowHeader, false),
updateType == GridUpdateType.Sort ? GridUpdateType.Refresh : updateType);
DataGrid?.MeasurePoints(
Points.GetAccessToPoints(DataGrid.ScrollDirection),
dataViewport,
data.Grid,
updateType == GridUpdateType.Sort ? GridUpdateType.Refresh : updateType);
// adjust Offset in case of overflow
if ((Points.HorizontalOffset + visualViewport.Width).GreaterThanOrClose(Points.HorizontalExtent))
{
Points.HorizontalOffset = Points.HorizontalExtent - visualViewport.Width;
}
if ((Points.VerticalOffset + visualViewport.Height).GreaterThanOrClose(Points.VerticalExtent))
{
Points.VerticalOffset = Points.VerticalExtent - visualViewport.Height;
}
// arrange and draw gridline
ColumnHeader?.ArrangeVisuals(Points.GetAccessToPoints(ColumnHeader.ScrollDirection));
RowHeader?.ArrangeVisuals(Points.GetAccessToPoints(RowHeader.ScrollDirection));
DataGrid?.ArrangeVisuals(Points.GetAccessToPoints(DataGrid.ScrollDirection));
Points.ViewportHeight = DataGrid.RenderSize.Height;
Points.ViewportWidth = DataGrid.RenderSize.Width;
}
}
private void CreateGrid(GridRange newViewport, IGrid <string> data, GridUpdateType updateType)
{
var orgGrid = _visualGrid;
if (Header)
{
_visualGrid = new Grid <TextVisual>(
newViewport,
(r, c) => {
if (updateType == GridUpdateType.Sort)
{
return(orgGrid[r, c]);
}
if (updateType != GridUpdateType.Refresh && _dataViewport.Contains(r, c))
{
return(orgGrid[r, c]);
}
var visual = new HeaderTextVisual(c);
InitVisual(r, c, data, visual);
return(visual);
});
}
else
{
_visualGrid = new Grid <TextVisual>(
newViewport,
(r, c) => {
if (updateType != GridUpdateType.Refresh && _dataViewport.Contains(r, c))
{
return(orgGrid[r, c]);
}
var visual = new TextVisual();
InitVisual(r, c, data, visual);
return(visual);
});
}
}
internal void EnqueueCommand(GridUpdateType code, double param) {
_scrollCommands.Add(new ScrollCommand(code, param));
}
private void DrawVisuals(
GridRange dataViewport,
IGridData<string> data,
GridUpdateType updateType,
Rect visualViewport,
bool suppressNotification) {
using (var deferal = Points.DeferChangeNotification(suppressNotification)) {
// measure points
ColumnHeader?.MeasurePoints(
Points.GetAccessToPoints(ColumnHeader.ScrollDirection),
new GridRange(new Range(0, 1), dataViewport.Columns),
new RangeToGrid<string>(dataViewport.Columns, data.ColumnHeader, true),
updateType);
RowHeader?.MeasurePoints(
Points.GetAccessToPoints(RowHeader.ScrollDirection),
new GridRange(dataViewport.Rows, new Range(0, 1)),
new RangeToGrid<string>(dataViewport.Rows, data.RowHeader, false),
updateType == GridUpdateType.Sort ? GridUpdateType.Refresh : updateType);
DataGrid?.MeasurePoints(
Points.GetAccessToPoints(DataGrid.ScrollDirection),
dataViewport,
data.Grid,
updateType == GridUpdateType.Sort ? GridUpdateType.Refresh : updateType);
// adjust Offset in case of overflow
if ((Points.HorizontalOffset + visualViewport.Width).GreaterThanOrClose(Points.HorizontalExtent)) {
Points.HorizontalOffset = Points.HorizontalExtent - visualViewport.Width;
}
if ((Points.VerticalOffset + visualViewport.Height).GreaterThanOrClose(Points.VerticalExtent)) {
Points.VerticalOffset = Points.VerticalExtent - visualViewport.Height;
}
// arrange and draw gridline
ColumnHeader?.ArrangeVisuals(Points.GetAccessToPoints(ColumnHeader.ScrollDirection));
RowHeader?.ArrangeVisuals(Points.GetAccessToPoints(RowHeader.ScrollDirection));
DataGrid?.ArrangeVisuals(Points.GetAccessToPoints(DataGrid.ScrollDirection));
Points.ViewportHeight = DataGrid.RenderSize.Height;
Points.ViewportWidth = DataGrid.RenderSize.Width;
}
}
private async Task DrawVisualsAsync(GridUpdateType updateType, bool suppressNotification, CancellationToken token, ISortOrder sortOrder) {
Rect visualViewport = new Rect(
Points.HorizontalOffset,
Points.VerticalOffset,
Points.ViewportWidth,
Points.ViewportHeight);
GridRange newViewport = Points.ComputeDataViewport(visualViewport);
if (newViewport.Rows.Count < 1 || newViewport.Columns.Count < 1) {
return;
}
// pull data from provider
try {
var data = await DataProvider.GetAsync(newViewport, sortOrder);
if (data == null) {
throw new InvalidOperationException("Couldn't fetch grid data");
}
if (!data.Grid.Range.Contains(newViewport)
|| !data.ColumnHeader.Range.Contains(newViewport.Columns)
|| !data.RowHeader.Range.Contains(newViewport.Rows)) {
throw new InvalidOperationException("Couldn't acquire enough data");
}
// actual drawing runs in UI thread
await Task.Factory.StartNew(
() => DrawVisuals(newViewport, data, updateType, visualViewport, suppressNotification),
token,
TaskCreationOptions.None,
_ui);
} catch (OperationCanceledException) { }
}
private bool IsRepeating(List<ScrollCommand> commands, int index, GridUpdateType[] scrollTypes) {
return commands[index].UpdateType == commands[index + 1].UpdateType && scrollTypes.Contains(commands[index].UpdateType);
}
internal void EnqueueCommand(GridUpdateType code, object param) => _scrollCommands.Post(new ScrollCommand(code, param));
private async Task DrawVisualsAsync(GridRange dataViewport, IGridData <string> data, GridUpdateType updateType, Rect visualViewport, bool suppressNotification, CancellationToken token)
{
await _services.MainThread().SwitchToAsync(token);
DataGrid.SelectedIndex = new GridIndex(Math.Min(DataGrid.SelectedIndex.Row, DataProvider.RowCount - 1), Math.Min(DataGrid.SelectedIndex.Column, DataProvider.ColumnCount - 1));
var columnsData = new RangeToGrid <string>(dataViewport.Columns, data.ColumnHeader, true);
var rowsData = new RangeToGrid <string>(dataViewport.Rows, data.RowHeader, false);
var cellsData = data.Grid;
using (Points.DeferChangeNotification(suppressNotification)) {
// measure points
ColumnHeader.MeasurePoints(
Points.GetAccessToPoints(ColumnHeader.ScrollDirection),
new GridRange(new Range(0, 1), dataViewport.Columns),
columnsData,
updateType);
RowHeader.MeasurePoints(
Points.GetAccessToPoints(RowHeader.ScrollDirection),
new GridRange(dataViewport.Rows, new Range(0, 1)),
rowsData,
updateType == Sort ? Refresh : updateType);
DataGrid.MeasurePoints(
Points.GetAccessToPoints(DataGrid.ScrollDirection),
dataViewport,
cellsData,
updateType == Sort ? Refresh : updateType);
// adjust Offset in case of overflow
if ((Points.HorizontalOffset + visualViewport.Width).GreaterOrCloseTo(Points.HorizontalExtent))
{
Points.HorizontalOffset = Points.HorizontalExtent - visualViewport.Width;
}
if ((Points.VerticalOffset + visualViewport.Height).GreaterOrCloseTo(Points.VerticalExtent))
{
Points.VerticalOffset = Points.VerticalExtent - visualViewport.Height;
}
if (updateType == ScrollIntoView)
{
AdjustFocusedCellOffset(visualViewport);
}
// arrange and draw gridline
ColumnHeader.ArrangeVisuals(Points.GetAccessToPoints(ColumnHeader.ScrollDirection));
RowHeader.ArrangeVisuals(Points.GetAccessToPoints(RowHeader.ScrollDirection));
DataGrid.ArrangeVisuals(Points.GetAccessToPoints(DataGrid.ScrollDirection));
Points.ViewportHeight = DataGrid.RenderSize.Height;
Points.ViewportWidth = DataGrid.RenderSize.Width;
}
DataViewport = dataViewport;
Data = data;
_owner.AutomationPeer?.Update();
}
internal void EnqueueCommand(GridUpdateType code, double param)
{
_scrollCommands.Add(new ScrollCommand(code, param));
}
internal void MeasurePoints(IPoints points, GridRange newViewport, IGrid<string> data, GridUpdateType updateType) {
CreateGrid(newViewport, data, updateType);
_visualChildren.Clear();
foreach (int c in newViewport.Columns.GetEnumerable()) {
foreach (int r in newViewport.Rows.GetEnumerable()) {
var visual = _visualGrid[r, c];
visual.Draw();
points.Width[c] = visual.Size.Width + (visual.Margin * 2) + GridLineThickness;
points.Height[r] = visual.Size.Height + (visual.Margin * 2) + GridLineThickness;
_visualChildren.Add(_visualGrid[r, c]);
}
}
_dataViewport = newViewport;
}
internal void EnqueueCommand(GridUpdateType code, double offset, ThumbTrack track) {
_scrollCommands.Add(new ScrollCommand(code, offset, track));
}
internal void EnqueueCommand(GridUpdateType code, double offset, ThumbTrack track)
{
_scrollCommands.Add(new ScrollCommand(code, offset, track));
}
internal void EnqueueCommand(GridUpdateType code, Size size)
{
_scrollCommands.Add(new ScrollCommand(code, size));
}
public ScrollCommand(GridUpdateType code, Size size) {
Debug.Assert(code == GridUpdateType.SizeChange);
UpdateType = code;
Param = size;
}
internal void EnqueueCommand(GridUpdateType code, Size size) {
_scrollCommands.Add(new ScrollCommand(code, size));
}
internal void MeasurePoints(IPoints points, GridRange newViewport, IGrid <string> data, GridUpdateType updateType)
{
CreateGrid(newViewport, data, updateType);
_visualChildren.Clear();
foreach (int c in newViewport.Columns.GetEnumerable())
{
foreach (int r in newViewport.Rows.GetEnumerable())
{
var visual = _visualGrid[r, c];
visual.Draw();
points.Width[c] = visual.Size.Width + (visual.Margin * 2) + GridLineThickness;
points.Height[r] = visual.Size.Height + (visual.Margin * 2) + GridLineThickness;
_visualChildren.Add(_visualGrid[r, c]);
}
}
_dataViewport = newViewport;
}
private void CreateGrid(GridRange newViewport, IGrid<string> data, GridUpdateType updateType) {
var orgGrid = _visualGrid;
if (Header) {
_visualGrid = new Grid<TextVisual>(
newViewport,
(r, c) => {
if (updateType == GridUpdateType.Sort) {
return orgGrid[r, c];
}
if (updateType != GridUpdateType.Refresh && _dataViewport.Contains(r, c)) {
return orgGrid[r, c];
}
var visual = new HeaderTextVisual(c);
InitVisual(r, c, data, visual);
return visual;
});
} else {
_visualGrid = new Grid<TextVisual>(
newViewport,
(r, c) => {
if (updateType != GridUpdateType.Refresh && _dataViewport.Contains(r, c)) {
return orgGrid[r, c];
}
var visual = new TextVisual();
InitVisual(r, c, data, visual);
return visual;
});
}
}
public ScrollCommand(GridUpdateType code, object param)
{
UpdateType = code;
Param = param;
}
