/// <summary> /// Creates a request to format cells /// <para></para> /// THROWS: InvalidOperationException /// </summary> /// <param name="spreadsheetId">The id of the sheets doc</param> /// <param name="tabName">The name of the tab to be formatted</param> /// <param name="format">The cell format to apply to the cells</param> /// <param name="range">The range to apply the format to</param> /// <returns></returns> private static Request requestFormatCells(string spreadsheetId, string tabName, CellFormat format, GridRange range) { int?sheetIndex = getTabIndex(spreadsheetId, tabName); // if the name was not found return if (sheetIndex == null) { throw new InvalidOperationException(m_errorTabDoesNotExist); } CellData cellData = new CellData(); cellData.UserEnteredFormat = format; GridRange grid = range; RepeatCellRequest repeatRequest = new RepeatCellRequest(); repeatRequest.Cell = cellData; repeatRequest.Fields = "UserEnteredFormat"; repeatRequest.Range = grid; Request request = new Request(); request.RepeatCell = repeatRequest; return(request); }
/// <summary> /// Applies the data and format of a list of rows to a range. /// </summary> /// <param name="spreadsheetId">The id of the sheets doc</param> /// <param name="tabName">The name of the tab to write to</param> /// <param name="startCell">The top-left cell in the range to be written to</param> /// <param name="endCell">The bottom-right cell in the range to be written to</param> /// <param name="rows">The list of rows to be written</param> /// <returns></returns> public static bool updateCells(string spreadsheetId, string tabName, string startCell, string endCell, List <RowData> rows) { if (m_shouldRun == false) { return(false); } Point startPoint = convertCellToPoint(startCell); Point endPoint = convertCellToPoint(endCell); GridRange range = new GridRange(); range.SheetId = getTabIndex(spreadsheetId, tabName); range.StartColumnIndex = startPoint.X; range.StartRowIndex = startPoint.Y; range.EndColumnIndex = endPoint.X + 1; range.EndRowIndex = endPoint.Y + 1; Request updateCells = requestUpdateCells(spreadsheetId, tabName, rows, range, "*"); Request autoSize = requestDimensionAutoSize(spreadsheetId, tabName, 0); BatchUpdateSpreadsheetRequest batchRequest = new BatchUpdateSpreadsheetRequest(); batchRequest.Requests = new List <Request>(); batchRequest.Requests.Add(autoSize); batchRequest.Requests.Add(updateCells); return(ExecuteBatchRequest(batchRequest, spreadsheetId)); }
/// <summary> /// Formats a range of cells /// </summary> /// <param name="spreadsheetId">The id of the sheets doc</param> /// <param name="tabName">The name of the tab to format</param> /// <param name="startCell">The top-left cell in the range to be formatted</param> /// <param name="endCell">The bottom right cell in the range to be formatted</param> /// <param name="format">The cell format to apply to the range</param> /// <returns></returns> public static bool FormatCellRange(string spreadsheetId, string tabName, string startCell, string endCell, CellFormat format) { if (m_shouldRun == false) { return(false); } Point startPoint = convertCellToPoint(startCell); Point endPoint = convertCellToPoint(endCell); GridRange gridRange = new GridRange(); gridRange.SheetId = getTabIndex(spreadsheetId, tabName); gridRange.StartColumnIndex = startPoint.X; gridRange.StartRowIndex = startPoint.Y - 1; gridRange.EndColumnIndex = endPoint.X + 1; gridRange.EndRowIndex = endPoint.Y + 1; Request formatCells = requestFormatCells(spreadsheetId, tabName, format, gridRange); BatchUpdateSpreadsheetRequest batchRequest = new BatchUpdateSpreadsheetRequest(); batchRequest.Requests = new List <Request>(); batchRequest.Requests.Add(formatCells); return(ExecuteBatchRequest(batchRequest, spreadsheetId)); }
public void Draw( GridRange range, IPoints points) { DrawingContext drawingContext = RenderOpen(); DoubleCollection xCollection = new DoubleCollection(); DoubleCollection yCollection = new DoubleCollection(); try { // vertical line double renderHeight = points.yPosition[range.Rows.Start + range.Rows.Count] - points.yPosition[range.Rows.Start]; Rect verticalLineRect = new Rect(new Size(GridLineThickness, renderHeight)); foreach (int i in range.Columns.GetEnumerable()) { verticalLineRect.X = points.xPosition[i + 1] - GridLineThickness; drawingContext.DrawRectangle(GridLineBrush, null, verticalLineRect); xCollection.Add(verticalLineRect.X); } // horizontal line double renderWidth = points.xPosition[range.Columns.Start + range.Columns.Count] - points.xPosition[range.Columns.Start]; Rect horizontalLineRect = new Rect(new Size(renderWidth, GridLineThickness)); foreach (int i in range.Rows.GetEnumerable()) { horizontalLineRect.Y = points.yPosition[i + 1] - GridLineThickness; drawingContext.DrawRectangle(GridLineBrush, null, horizontalLineRect); yCollection.Add(horizontalLineRect.Y); } XSnappingGuidelines = xCollection; YSnappingGuidelines = yCollection; } finally { drawingContext.Close(); } }
public List <string> GetGames() { IList <IList <object> > values = Response.Values; if (values != null && values.Count > 0) { List <string> Games = new List <string>(); for (int i = 3; i < values.Count; ++i) { var row = values[i]; if (row.Count > 4 && row[4] != null && !string.IsNullOrWhiteSpace(row[4].ToString())) { Games.Add(row[4].ToString()); LastGameId = i; } } Sheet sh = Service.Spreadsheets.Get(SpreadsheetId).Execute().Sheets.Where(s => s.Properties.Title == Name).FirstOrDefault(); GridRange merge = sh.Merges.Where(m => m.StartRowIndex == LastGameId && m.StartColumnIndex == 4).FirstOrDefault(); int? index = merge?.EndRowIndex; if (index != null) { LastGameId = index.GetValueOrDefault() - 1; } return(Games); } else { Console.WriteLine("No data found."); return(null); } }
/// <summary> /// Default constructor for the class. /// </summary> /// <param name="sheet"></param> /// <param name="range"></param> public MergedRegion(Sheet sheet, GridRange range) { _sheet = sheet; Range = range; A1FirstCell = CalculateFirstCellA1(); }
/// <summary> /// As opposed to Adding a range, this will remove a range. /// It might happend that removing a range is dividing one bigger range into two /// smaller ones. So practically the number of ranges might increase. /// /// It might be that this method might carry more exact meaning with "Exclude", instead /// of "RemoveRange" /// </summary> /// <param name="rangeToRemove"></param> /// <returns></returns> public RangeMergerByRows RemoveRange(GridRange rangeToRemove) { while (RemoveRangeRecursive(rangeToRemove)) { } return(this); }
/// <summary> /// Construct a quadtree node with the given bounds /// </summary> public QuadTreeNode(GridRange bounds, int currentDepth, QuadTree quadTree) : this(bounds) { m_bounds = bounds; QuadTree = quadTree; Depth = currentDepth + 1; }
private bool IntersectWithCurrentRangesRecursive(RangeRegion rangeRegionToIntersect) { // check against each range foreach (GridRange range in m_ranges) { RangeRegion excludedResults = null; GridRange remove = GridRange.Empty; bool excluded = false; // loop through our new ranges foreach (GridRange rangeToIntersect in rangeRegionToIntersect) { // if we intersect with at least one range // get the exclusion range. // mark a flag, that we need to remove our // range, and add an excluded range if (range.IntersectsWith(rangeToIntersect)) { excludedResults = rangeToIntersect.Exclude(range); excluded = true; remove = rangeToIntersect; break; } } if (excluded) { rangeRegionToIntersect.Remove(remove); rangeRegionToIntersect.Add(excludedResults); return(true); } } return(false); }
private void VerifyVerticalStretches() { if (GridRange.VerticallyIntersectsWith(Template.GridRows.Count - Template.Stretches)) { throw new InvalidOperationException(DiagnosticMessages.ScalarBinding_InvalidStretches(Ordinal)); } }
public QuadTreeNode CreateNewRoot(QuadTreeNode currentRoot) { var bounds = currentRoot.Bounds; int startRow = bounds.Start.Row; int startCol = bounds.Start.Column; int halfCol = bounds.ColumnsCount; int halfRow = bounds.RowsCount; var Depth = currentRoot.Depth; var QuadTree = currentRoot.QuadTree; var newRoot = new QuadTreeNode( new GridRange(startRow, startCol, halfCol * 2, halfRow * 2), currentRoot.Depth, currentRoot.QuadTree); newRoot.Nodes.Add(currentRoot); newRoot.Nodes.Add(new QuadTreeNode(GridRange.From( new Position(startRow, startCol + halfCol), halfRow, halfCol), Depth, QuadTree)); newRoot.Nodes.Add(new QuadTreeNode(GridRange.From( new Position(startRow + halfRow, startCol), halfRow, halfCol), Depth, QuadTree)); newRoot.Nodes.Add(new QuadTreeNode(GridRange.From( new Position(startRow + halfRow, startCol + halfCol), halfRow, halfCol), Depth, QuadTree)); return(newRoot); }
public void CreateSubNodes(QuadTreeNode parentNode) { var m_bounds = parentNode.Bounds; // the smallest subnode has an area if ((parentNode.Bounds.ColumnsCount * parentNode.Bounds.RowsCount) <= 10) { return; } int startRow = m_bounds.Start.Row; int startCol = m_bounds.Start.Column; int halfCol = (m_bounds.ColumnsCount / 2); int halfRow = (m_bounds.RowsCount / 2); var Depth = parentNode.Depth; var QuadTree = parentNode.QuadTree; parentNode.Nodes.Add(new QuadTreeNode(GridRange.From(m_bounds.Start, halfRow, halfCol), Depth, QuadTree)); parentNode.Nodes.Add(new QuadTreeNode(GridRange.From( new Position(startRow, startCol + halfCol), halfRow, halfCol), Depth, QuadTree)); parentNode.Nodes.Add(new QuadTreeNode(GridRange.From( new Position(startRow + halfRow, startCol), halfRow, halfCol), Depth, QuadTree)); parentNode.Nodes.Add(new QuadTreeNode(GridRange.From( new Position(startRow + halfRow, startCol + halfCol), halfRow, halfCol), Depth, QuadTree)); }
public virtual System.Drawing.Bitmap Export(GridVirtual grid, GridRange rangeToExport) { System.Drawing.Bitmap bitmap = null; try { System.Drawing.Size size = grid.RangeToSize(rangeToExport); bitmap = new System.Drawing.Bitmap(size.Width, size.Height); using (System.Drawing.Graphics graphic = System.Drawing.Graphics.FromImage(bitmap)) { Export(grid, graphic, rangeToExport, new System.Drawing.Point(0, 0)); } } catch (Exception) { if (bitmap != null) { bitmap.Dispose(); bitmap = null; } throw; } return(bitmap); }
internal override void VerifyRowRange(GridRange rowRange) { if (GridRange.IntersectsWith(rowRange)) { throw new InvalidOperationException(DiagnosticMessages.ScalarBinding_IntersectsWithRowRange(Ordinal)); } if (!RepeatsWhenFlow) { return; } if (Template.Flowable(Orientation.Horizontal)) { if (!rowRange.Contains(GridRange.Left) || !rowRange.Contains(GridRange.Right)) { throw new InvalidOperationException(DiagnosticMessages.ScalarBinding_OutOfHorizontalRowRange(Ordinal)); } } else if (Template.Flowable(Orientation.Vertical)) { if (!rowRange.Contains(GridRange.Top) || !rowRange.Contains(GridRange.Bottom)) { throw new InvalidOperationException(DiagnosticMessages.ScalarBinding_OutOfVerticalRowRange(Ordinal)); } } else { throw new InvalidOperationException(DiagnosticMessages.ScalarBinding_FlowRepeatableNotAllowedByTemplate(Ordinal)); } }
public bool Remove(GridRange range) { // if the item is not contained in this quad, there's a problem if (!m_bounds.Contains(range)) { throw new ArgumentException("range is out of the bounds of this quadtree node"); } // for each subnode: // if the node contains the item, add the item to that node and return // this recurses into the node that is just large enough to fit this item foreach (QuadTreeNode node in m_nodes) { if (node.Bounds.Contains(range)) { return(node.Remove(range)); } } for (int i = 0; i < Contents.Count; i++) { if (Contents[i].Equals(range)) { Contents.RemoveAt(i); return(true); } } return(false); }
public override void SelectRange(GridRange range, bool select) { for (int c = range.Start.Column; c <= range.End.Column; c++) { SelectColumn(c, select); } }
public TileRegionFilter(SQuantizedExtentGrid <int> grid, SQuantizedExtent3D quantizedExtent, GridRange tileRange) { m_range = tileRange; m_grid = grid; m_quantizedExtent = quantizedExtent; }
/// <summary> /// Insert an item to this node /// </summary> /// <param name="item"></param> public void Insert(GridRange item) { // if the item is not contained in this quad, there's a problem if (!m_bounds.Contains(item)) { throw new ArgumentException("range is out of the bounds of this quadtree node"); } // if the subnodes are null create them. may not be sucessfull: see below // we may be at the smallest allowed size in which case the subnodes will not be created if (m_nodes.Count == 0) { QuadTree.QuadTreeNodeDivider.CreateSubNodes(this); } // for each subnode: // if the node contains the item, add the item to that node and return // this recurses into the node that is just large enough to fit this item foreach (QuadTreeNode node in m_nodes) { if (node.Bounds.Contains(item)) { node.Insert(item); return; } } // if we make it to here, either // 1) none of the subnodes completely contained the item. or // 2) we're at the smallest subnode size allowed // add the item to this node's contents. this.Contents.Add(item); }
internal override void VerifyRowRange(GridRange rowRange) { if (GridRange.IntersectsWith(rowRange)) { throw new InvalidOperationException(DiagnosticMessages.BlockBinding_IntersectsWithRowRange(Ordinal)); } if (!Template.Orientation.HasValue) { throw new InvalidOperationException(DiagnosticMessages.BlockBinding_NullOrientation); } var orientation = Template.Orientation.GetValueOrDefault(); if (orientation == Orientation.Horizontal) { if (!rowRange.Contains(GridRange.Left) || !rowRange.Contains(GridRange.Right)) { throw new InvalidOperationException(DiagnosticMessages.BlockBinding_OutOfHorizontalRowRange(Ordinal)); } } else { Debug.Assert(orientation == Orientation.Vertical); if (!rowRange.Contains(GridRange.Top) || !rowRange.Contains(GridRange.Bottom)) { throw new InvalidOperationException(DiagnosticMessages.BlockBinding_OutOfVerticalRowRange(Ordinal)); } } }
internal sealed override void VerifyRowRange(GridRange rowRange) { if (!rowRange.Contains(GridRange)) { throw new InvalidOperationException(DiagnosticMessages.RowBinding_OutOfRowRange(Ordinal)); } }
/// <summary> /// Add a range to collection. If the range can be added (merged) /// to existing range, it will be added so. This will guarantee /// that the number of different ranges is kept to minimal. /// In theory only if user selects every second row, this would produce /// RowCount / 2 number of ranges. In practice, there are rarely /// more than 3 - 5 different selection regions /// </summary> /// <param name="rangeToAdd">columns values are ignored, so simply /// put 0 as start colum and 1 as end column. Only row values matter</param> /// <returns></returns> public RangeMergerByRows AddRange(GridRange rangeToAdd) { rangeToAdd = NormalizeRange(rangeToAdd); Merge(rangeToAdd); JoinAdjanced(); return(this); }
public Task <IGridData <string> > GetAsync(GridRange range) { return(Task.Run(async() => { await Task.Delay(TimeSpan.FromMilliseconds(100)); return (IGridData <string>) new MockGridData(range); })); }
/// <summary> /// Query the QuadTree for items that are in the given area /// </summary> /// <returns></returns> public List <GridRange> QueryInternal(GridRange queryArea, bool stopOnFirst) { // create a list of the items that are found List <GridRange> results = new List <GridRange>(); // this quad contains items that are not entirely contained by // it's four sub-quads. Iterate through the items in this quad // to see if they intersect. foreach (var item in this.Contents) { if (queryArea.IntersectsWith(item)) { results.Add(item); if (stopOnFirst == true) { return(results); } } } foreach (QuadTreeNode node in m_nodes) { if (node.IsEmpty) { continue; } // Case 1: search area completely contained by sub-quad // if a node completely contains the query area, go down that branch // and skip the remaining nodes (break this loop) if (node.Bounds.Contains(queryArea)) { results.AddRange(node.QueryInternal(queryArea, stopOnFirst)); break; } // Case 2: Sub-quad completely contained by search area // if the query area completely contains a sub-quad, // just add all the contents of that quad and it's children // to the result set. You need to continue the loop to test // the other quads if (queryArea.Contains(node.Bounds)) { results.AddRange(node.SubTreeContents); continue; } // Case 3: search area intersects with sub-quad // traverse into this quad, continue the loop to search other // quads if (node.Bounds.IntersectsWith(queryArea)) { results.AddRange(node.QueryInternal(queryArea, stopOnFirst)); } } return(results); }
private void Join(GridRange range1, GridRange range2) { GridRange result = GridRange.GetBounds(range1, range2); m_ranges.Remove(range1); m_ranges.Remove(range2); m_ranges.Add(result); }
/*------------------------------------------------------------------------------------------------------------------*/ /********************************************************************************************************************/ /*************************************************** Behaviours *****************************************************/ /********************************************************************************************************************/ /*------------------------------------------------------------------------------------------------------------------*/ /*^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ DEBUG ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/ /// <summary> /// Ensures there is always at least some room to deploy. /// </summary> protected void InitializeDeploymentZone() { deployArea = new GridRange(deployRangeTopLeftTile, deployRangeBottomRightTile); if (deployArea.Area == 0) { throw new InvalidDeployAreaException("The deployment area contains 0 valid tiles."); } }
public MockGridData(GridRange range) { ColumnHeader = new DefaultHeaderData(range.Columns, DefaultHeaderData.Mode.Column); RowHeader = new DefaultHeaderData(range.Rows, DefaultHeaderData.Mode.Row); Grid = new Grid <string>(range, (r, c) => Invariant($"{r}:{c}")); }
public void MergeRange(GridRange range) { if (_sheet.Merges == null) { _sheet.Merges = new List <GridRange>(); } range.SheetId = _sheet.Properties.SheetId; _sheet.Merges.Add(range); }
public override bool IntersectsWith(GridRange rng) { for (int c = rng.Start.Column; c <= rng.End.Column; c++) { if (IsSelectedColumn(c)) return true; } return false; }
public override bool IsSelectedRange(GridRange range) { for (int c = range.Start.Column; c <= range.End.Column; c++) { if (IsSelectedColumn(c) == false) return false; } return true; }
private void SetHeight(GridVirtual grid, Position position, int height) { GridRange range = grid.PositionToCellRange(position); int heightForCol = height / range.RowsCount; for (int r = range.Start.Row; r <= range.End.Row; r++) { grid.Rows.SetHeight(r, heightForCol); } }
public GridRange?QueryFirst(GridRange queryArea) { var results = QueryInternal(queryArea, true); if (results.Count == 0) { return(null); } return(results[0]); }
public static async Task<IGridData<string>> GetGridDataAsync(IRSession rSession, string expression, GridRange? gridRange, ISortOrder sortOrder = null) { await TaskUtilities.SwitchToBackgroundThread(); string rows = gridRange?.Rows.ToRString(); string columns = gridRange?.Columns.ToRString(); string rowSelector = (sortOrder != null && !sortOrder.IsEmpty) ? sortOrder.GetRowSelector() : ""; string expr = Invariant($"rtvs:::grid_data({expression}, {rows}, {columns}, {rowSelector})"); try { return await rSession.EvaluateAsync<GridData>(expr, REvaluationKind.Normal); } catch (RException ex) { var message = Invariant($"Grid data evaluation failed:{Environment.NewLine}{ex.Message}"); await VsAppShell.Current.Services.Log.WriteAsync(LogVerbosity.Normal, MessageCategory.Error, message); return null; } }
public static async Task<IGridData<string>> GetGridDataAsync(string expression, GridRange gridRange, IRSession rSession = null) { await TaskUtilities.SwitchToBackgroundThread(); if (rSession == null) { rSession = VsAppShell.Current.ExportProvider.GetExportedValue<IRSessionProvider>().GetInteractiveWindowRSession(); if (rSession == null) { throw new InvalidOperationException(Invariant($"{nameof(IRSessionProvider)} failed to return RSession for {nameof(EvaluationWrapper)}")); } } string rows = gridRange.Rows.ToRString(); string columns = gridRange.Columns.ToRString(); REvaluationResult? result = null; using (var evaluator = await rSession.BeginEvaluationAsync(false)) { result = await evaluator.EvaluateAsync($"rtvs:::grid.dput(rtvs:::grid.data({expression}, {rows}, {columns}))", REvaluationKind.Normal); if (result.Value.ParseStatus != RParseStatus.OK || result.Value.Error != null) { throw new InvalidOperationException($"Grid data evaluation failed:{result}"); } } GridData data = null; if (result.HasValue) { data = GridParser.Parse(result.Value.StringResult.ToUnicodeQuotes()); data.Range = gridRange; if ((data.ValidHeaderNames.HasFlag(GridData.HeaderNames.Row) && data.RowNames.Count != gridRange.Rows.Count) || (data.ValidHeaderNames.HasFlag(GridData.HeaderNames.Column) && data.ColumnNames.Count != gridRange.Columns.Count)) { throw new InvalidOperationException("Header names lengths are different from data's length"); } } return data; }
internal void MeasurePoints(IPoints points, GridRange newViewport, IGrid<string> data, bool refresh) { var orgGrid = _visualGrid; _visualGrid = new Grid<TextVisual>( newViewport, (r, c) => { if (!refresh && _dataViewport.Contains(r, c)) { return orgGrid[r, c]; } var visual = new TextVisual(); visual.Row = r; visual.Column = c; visual.Text = data[r, c]; visual.Typeface = Typeface; visual.FontSize = FontSize; // FontSize here is in device independent pixel, and Visual's FormattedText API uses the same unit visual.Foreground = Foreground; return visual; }); _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; }); } }
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 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; } }
public static Task<IGridData<string>> GetGridDataAsync(string expression, GridRange? gridRange, ISortOrder sortOrder = null) => GetGridDataAsync(VsAppShell.Current.ExportProvider.GetExportedValue<IRInteractiveWorkflowProvider>().GetOrCreate().RSession, expression, gridRange, sortOrder);