Restore scale change

Author: CyLuGh

src/HierarchyGrid.Avalonia/Grid.axaml.cs

@@ -222,8 +222,8 @@ HierarchyGridViewModel viewModel
         var width = canvas.LocalClipBounds.Width;
         var height = canvas.LocalClipBounds.Height;
 
-        var scale = 1d;
-        await HierarchyGridDrawer.Draw(viewModel, canvas, width, height, scale, false);
+        // Avalonia does not need screen scale adjustment with windows zoomed display
+        await HierarchyGridDrawer.Draw(viewModel, canvas, width, height, 1d, false);
     }
 
     private static void SkiaElement_PointerMove(
@@ -233,7 +233,7 @@ HierarchyGridViewModel viewModel
     )
     {
         var position = args.GetPosition(element);
-        viewModel.HandleMouseOver(position.X, position.Y, 1);
+        viewModel.HandleMouseOver(position.X, position.Y, viewModel.Scale);
     }
 
     private static void SkiaElement_PointerExit(HierarchyGridViewModel viewModel)

src/HierarchyGrid.Definitions/ElementCoordinates.cs

@@ -13,19 +13,31 @@ public readonly record struct ElementCoordinates
     public double Right { get; init; }
     public double Bottom { get; init; }
 
-    public ElementCoordinates(double left, double top, double right, double bottom) =>
-        (Left, Top, Right, Bottom) = (left, top, right, bottom);
-
-    public ElementCoordinates(PositionedCell cell) =>
+    public ElementCoordinates(
+        double left,
+        double top,
+        double right,
+        double bottom,
+        double screenScale
+    ) =>
         (Left, Top, Right, Bottom) = (
-            cell.Left,
-            cell.Top,
-            cell.Left + cell.Width,
-            cell.Top + cell.Height
+            screenScale * left,
+            screenScale * top,
+            screenScale * right,
+            screenScale * bottom
         );
 
     public bool Contains(double x, double y) => Left <= x && x <= Right && Top <= y && y <= Bottom;
 
     public double Height => Math.Abs(Top - Bottom);
+
+    public ElementCoordinates(PositionedCell cell, double screenScale) =>
+        (Left, Top, Right, Bottom) = (
+            screenScale * cell.Left,
+            screenScale * cell.Top,
+            screenScale * (cell.Left + cell.Width),
+            screenScale * (cell.Top + cell.Height)
+        );
+
     public double Width => Math.Abs(Right - Left);
 }

src/HierarchyGrid.Definitions/HierarchyGridViewModel.cs

@@ -749,14 +749,19 @@ var definition in ColumnsDefinitions
     /// <param name="height">The height of the area for which drawn cells are being retrieved.</param>
     /// <param name="invalidate">Specifies whether the existing drawn cells should be invalidated and recomputed.</param>
     /// <returns>A sequence of <see cref="PositionedCell"/> instances representing the cells currently drawn within the specified area.</returns>
-    public Seq<PositionedCell> GetDrawnCells(double width, double height, bool invalidate)
+    public Seq<PositionedCell> GetDrawnCells(
+        double width,
+        double height,
+        bool invalidate,
+        double screenScale = 1d
+    )
     {
         DrawnCells = GetDrawnCells(
             HorizontalOffset,
             VerticalOffset,
             width,
             height,
-            Scale,
+            screenScale * Scale,
             invalidate
         );
         return DrawnCells;

src/HierarchyGrid.Skia/CanvasExtensions.cs

@@ -41,7 +41,7 @@ internal static void DrawGlobalHeaders(
             HierarchyGridViewModel viewModel,
             SkiaTheme theme,
             IList<(ElementCoordinates, Guid)> previousGlobalCoordinates,
-            double screenScale = 1d
+            double screenScale
         )
         {
             // Don't draw if structure doesn't allow it
@@ -164,17 +164,19 @@ private static void DrawGlobalHeader(
             GlobalHeader globalHeader = GlobalHeader.Local
         )
         {
+            var actualScale = screenScale * viewModel.Scale;
             var rect = SKRect.Create(
-                (float)(left * screenScale),
-                (float)(top * screenScale),
-                (float)(width * screenScale),
-                (float)(height * screenScale)
+                (float)(left * actualScale),
+                (float)(top * actualScale),
+                (float)(width * actualScale),
+                (float)(height * actualScale)
             );
             var coordinates = new ElementCoordinates(
-                left * screenScale,
-                top * screenScale,
-                (left + width) * screenScale,
-                (top + height) * screenScale
+                left,
+                top,
+                (left + width),
+                (top + height),
+                actualScale
             );
 
             var isHovered = previousGlobalCoordinates
@@ -195,8 +197,8 @@ private static void DrawGlobalHeader(
 
             var decorator = GetGlobalHeaderDecorator(
                 !expanded,
-                left * screenScale,
-                top * screenScale,
+                left * actualScale,
+                top * actualScale,
                 globalHeader
             );
             paint.Color = isHovered
@@ -221,9 +223,11 @@ internal static void DrawColumnHeaders(
             Func<HierarchyGridViewModel, HierarchyDefinition[]> selector,
             float availableWidth,
             ref int headerCount,
-            double screenScale = 1d
+            double screenScale
         )
         {
+            var actualAvailableWidth = availableWidth / viewModel.Scale;
+
             viewModel.ColumnsParents.Clear();
             var hdefs = selector(viewModel).ToArr();
 
@@ -252,7 +256,7 @@ internal static void DrawColumnHeaders(
                 column++;
             }
 
-            while (column < hdefs.Length && currentPosition < availableWidth)
+            while (column < hdefs.Length && currentPosition < actualAvailableWidth)
             {
                 var hdef = hdefs[column];
                 var width = viewModel.ColumnsWidths[column];
@@ -402,6 +406,8 @@ internal static void DrawRowHeaders(
             double screenScale = 1d
         )
         {
+            var actualAvailableHeight = availableHeight / viewModel.Scale;
+
             viewModel.RowsParents.Clear();
             var hdefs = selector(viewModel).ToArr();
 
@@ -430,7 +436,7 @@ internal static void DrawRowHeaders(
                 row++;
             }
 
-            while (row < hdefs.Length && currentPosition < availableHeight)
+            while (row < hdefs.Length && currentPosition < actualAvailableHeight)
             {
                 var hdef = hdefs[row];
                 var height = viewModel.RowsHeights[row];
@@ -572,11 +578,12 @@ private static void DrawHeader(
             double screenScale
         )
         {
+            var actualScale = screenScale * viewModel.Scale;
             var rect = SKRect.Create(
-                (float)(left * screenScale),
-                (float)(top * screenScale),
-                (float)(width * screenScale),
-                (float)(height * screenScale)
+                (float)(left * actualScale),
+                (float)(top * actualScale),
+                (float)(width * actualScale),
+                (float)(height * actualScale)
             );
 
             var renderInfo = RenderInfo.FindRender(viewModel, theme, hdef);
@@ -590,7 +597,7 @@ double screenScale
             paint.Color = theme.BorderColor;
             canvas.DrawRect(rect, paint);
 
-            GetHeaderDecorator(hdef, left * screenScale, top * screenScale)
+            GetHeaderDecorator(hdef, left * actualScale, top * actualScale)
                 .IfSome(decorator =>
                 {
                     using var localPaint = new SKPaint();
@@ -606,13 +613,19 @@ double screenScale
                 top,
                 width,
                 height,
-                screenScale,
+                actualScale,
                 renderInfo,
                 viewModel.HeaderFontFamily,
                 viewModel.HeaderFontSize
             );
 
-            var coordinates = new ElementCoordinates(left, top, left + width, top + height);
+            var coordinates = new ElementCoordinates(
+                left,
+                top,
+                left + width,
+                top + height,
+                actualScale
+            );
             viewModel.HeadersCoordinates.Add(new(coordinates, new(coordinates, hdef)));
 
             headerCount++;
@@ -776,12 +789,11 @@ internal static void DrawCells(
             this SKCanvas canvas,
             HierarchyGridViewModel viewModel,
             SkiaTheme theme,
-            IEnumerable<PositionedCell> cells,
-            double screenScale = 1d
+            IEnumerable<PositionedCell> cells
         )
         {
             foreach (var cell in cells)
-                canvas.DrawCell(viewModel, theme, cell, screenScale);
+                canvas.DrawCell(viewModel, theme, cell);
         }
 
         private static void DrawCell(
@@ -792,11 +804,13 @@ private static void DrawCell(
             double screenScale = 1d
         )
         {
+            var actualScale = screenScale * viewModel.Scale;
+
             var rect = SKRect.Create(
-                (float)(cell.Left * screenScale),
-                (float)(cell.Top * screenScale),
-                (float)(cell.Width * screenScale),
-                (float)(cell.Height * screenScale)
+                (float)(cell.Left * actualScale),
+                (float)(cell.Top * actualScale),
+                (float)(cell.Width * actualScale),
+                (float)(cell.Height * actualScale)
             );
 
             var renderInfo = RenderInfo.FindRender(viewModel, theme, cell);
@@ -840,10 +854,10 @@ private static void DrawCell(
                     localPaint.Color = fci.BackgroundColor.ToSKColor();
 
                     rect = SKRect.Create(
-                        (float)(cell.Left * screenScale) + borderThickness,
-                        (float)(cell.Top * screenScale) + borderThickness,
-                        (float)(cell.Width * screenScale) - (borderThickness + 1f),
-                        (float)(cell.Height * screenScale) - (borderThickness + 1f)
+                        (float)(cell.Left * actualScale) + borderThickness,
+                        (float)(cell.Top * actualScale) + borderThickness,
+                        (float)(cell.Width * actualScale) - (borderThickness + 1f),
+                        (float)(cell.Height * actualScale) - (borderThickness + 1f)
                     );
                     canvas.DrawRect(rect, localPaint);
 
@@ -854,13 +868,13 @@ private static void DrawCell(
                     canvas.DrawRect(rect, localPaint);
                 });
 
-            DrawSelectionBorder(canvas, viewModel, theme, cell, screenScale, paint, ref rect);
+            DrawSelectionBorder(canvas, viewModel, theme, cell, actualScale, paint, ref rect);
 
-            RenderCellText(canvas, viewModel, theme, cell, screenScale, renderInfo);
-            RenderLeftSideDecor(canvas, cell, renderInfo, screenScale);
-            RenderRightSideDecor(canvas, cell, renderInfo, screenScale);
+            RenderCellText(canvas, viewModel, theme, cell, actualScale, renderInfo);
+            RenderLeftSideDecor(canvas, cell, renderInfo, actualScale);
+            RenderRightSideDecor(canvas, cell, renderInfo, actualScale);
 
-            viewModel.CellsCoordinates.Add((new(cell), cell));
+            viewModel.CellsCoordinates.Add((new(cell, viewModel.Scale), cell));
         }
 
         private static void RenderRightSideDecor(

src/HierarchyGrid.Skia/HierarchyGridDrawer.cs

@@ -13,7 +13,7 @@ public static async Task Draw(
             SKCanvas canvas,
             float width,
             float height,
-            double screenScale = 1d,
+            double screenScale,
             bool invalidate = false
         )
         {
@@ -23,7 +23,7 @@ public static async Task Draw(
             using var paintBackground = new SKPaint();
             paintBackground.Color = theme.BackgroundColor;
             paintBackground.Style = SKPaintStyle.StrokeAndFill;
-            var rectBackground = SKRect.Create(width, height);
+            var rectBackground = SKRect.Create(width, height); // TODO: check scale
             canvas.DrawRect(rectBackground, paintBackground);
 
             if (viewModel.HasData)
@@ -40,8 +40,7 @@ public static async Task Draw(
                 canvas.DrawCells(
                     viewModel,
                     theme,
-                    viewModel.GetDrawnCells(width, height, invalidate),
-                    screenScale
+                    viewModel.GetDrawnCells(width, height, invalidate, screenScale)
                 );
 
                 canvas.DrawColumnHeaders(
@@ -71,10 +70,13 @@ public static async Task Draw(
                 paint.IsAntialias = true;
                 paint.Color = theme.ForegroundColor;
 
+                var resultingScale = screenScale * viewModel.Scale;
+
+                // TODO: should probably not take all scale into account
                 canvas.DrawText(
                     viewModel.StatusMessage ?? "NO MESSAGE",
-                    (float)screenScale * width / 2,
-                    (float)screenScale * height / 2,
+                    (float)resultingScale * width / 2,
+                    (float)resultingScale * height / 2,
                     SKTextAlign.Center,
                     font,
                     paint

src/HierarchyGrid/Grid.xaml.cs

@@ -117,7 +117,11 @@ await HierarchyGridDrawer.Draw(
                 .MouseMove.Subscribe(args =>
                 {
                     var position = args.GetPosition(view.SkiaElement);
-                    viewModel.HandleMouseOver(position.X, position.Y, view.ScreenScale);
+                    viewModel.HandleMouseOver(
+                        position.X,
+                        position.Y,
+                        viewModel.Scale * view.ScreenScale
+                    );
                 })
                 .DisposeWith(disposables);