Improved region creation code, high-dpi support and sample addition

dotMorten · dotMorten · commit 53b5afbbe8c5 · 2025-10-13T12:41:59.000-07:00
diff --git a/src/WinUIEx/NativeMethods.txt b/src/WinUIEx/NativeMethods.txt
@@ -69,5 +69,9 @@ MonitorFromPoint
 IDI_APPLICATION
 CreateRectRgn
 CreateRoundRectRgn
+CreateEllipticRgn
+CreatePolygonRgn
 CombineRgn
 SetWindowRgn
+GetWindowRgn
+GetWindowRgnBox
diff --git a/src/WinUIEx/Region.cs b/src/WinUIEx/Region.cs
@@ -3,6 +3,7 @@
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using Microsoft.UI.Content;
 using Windows.Foundation;
 using Windows.Graphics;
 using Windows.Win32;
@@ -21,9 +22,19 @@ private class RectRegion : Region
         {
             private readonly Rect _rect;
             public RectRegion(Rect rect) { _rect = rect; }
-            internal override HRGN Create(double scalefactor)
-             => PInvoke.CreateRectRgn((int)(_rect.Left * scalefactor), (int)(_rect.Top * scalefactor),
-                    (int)(_rect.Right * scalefactor), (int)(_rect.Bottom * scalefactor));
+            internal override HRGN Create(ContentCoordinateConverter converter, PointInt32 screenLoc, double scaleFactor)
+            {
+                var p1 = Convert(_rect.Left, _rect.Top, converter, screenLoc, scaleFactor);
+                var p2 = Convert(_rect.Right, _rect.Bottom, converter, screenLoc, scaleFactor);
+                return PInvoke.CreateRectRgn(p1.X, p1.Y, p2.X, p2.Y);
+            }
+        }
+        private class RectInt32Region : Region
+        {
+            private readonly RectInt32 _rect;
+            public RectInt32Region(RectInt32 rect) { _rect = rect; }
+            internal override HRGN Create(ContentCoordinateConverter converter, PointInt32 screenLoc, double scaleFactor)
+             => PInvoke.CreateRectRgn(_rect.X, _rect.Y, _rect.X + _rect.Width, _rect.Y + _rect.Height);
         }
 
         private class RoundRectRegion : Region
@@ -37,9 +48,70 @@ public RoundRectRegion(Rect rect, double w, double h)
                 _w = w;
                 _h = h;
             }
-            internal override HRGN Create(double scalefactor)
-             => PInvoke.CreateRoundRectRgn((int)(_rect.Left * scalefactor), (int)(_rect.Top * scalefactor),
-                    (int)(_rect.Right * scalefactor), (int)(_rect.Bottom * scalefactor), (int)(_w * scalefactor), (int)(_h * scalefactor));
+            internal override HRGN Create(ContentCoordinateConverter converter, PointInt32 screenLoc, double scaleFactor)
+            {
+                var p1 = Convert(_rect.Left, _rect.Top, converter, screenLoc, scaleFactor);
+                var p2 = Convert(_rect.Right, _rect.Bottom, converter, screenLoc, scaleFactor);
+                return PInvoke.CreateRoundRectRgn(p1.X, p1.Y, p2.X, p2.Y, (int)(_w * scaleFactor), (int)(_h * scaleFactor));
+            }
+        }
+
+        private class EllipticRegion : Region
+        {
+            private readonly double _x1;
+            private readonly double _y1;
+            private readonly double _x2;
+            private readonly double _y2;
+            public EllipticRegion(double x1, double y1, double x2, double y2)
+            {
+                _x1 = x1;
+                _y1 = y1;
+                _x2 = x2;
+                _y2 = y2;
+            }
+            internal override HRGN Create(ContentCoordinateConverter converter, PointInt32 screenLoc, double scaleFactor)
+            { 
+                var p1 = Convert(_x1, _y1, converter, screenLoc, scaleFactor);
+                var p2 = Convert(_x2, _y2, converter, screenLoc, scaleFactor);
+                return PInvoke.CreateEllipticRgn(p1.X, p1.Y, p2.X, p2.Y);
+            }
+        }
+
+        private class PolygonRegion : Region
+        {
+            private readonly IEnumerable<Point> _points;
+            private readonly CREATE_POLYGON_RGN_MODE _mode;
+            public PolygonRegion(IEnumerable<Point> points, CREATE_POLYGON_RGN_MODE mode)
+            {
+                _points = points;
+                _mode = mode;
+            }
+            internal unsafe override HRGN Create(ContentCoordinateConverter converter, PointInt32 screenLoc, double scaleFactor)
+            {
+                var pint32 = converter.ConvertLocalToScreen(_points.Select(p => new Point(p.X * scaleFactor, p.Y * scaleFactor)).ToArray());
+                var array = pint32.Select(p => new System.Drawing.Point(p.X - screenLoc.X, p.Y - screenLoc.Y)).ToArray();
+                fixed (System.Drawing.Point* pArray = array)
+                    return PInvoke.CreatePolygonRgn(pArray, array.Length, _mode);
+            }
+             
+        }
+
+        private class CurrentRegion : Region
+        {
+            private nint _WindowHandle;
+            public CurrentRegion(nint windowHandle)
+            {
+                _WindowHandle = windowHandle;
+            }
+            internal override HRGN Create(ContentCoordinateConverter converter, PointInt32 screenLoc, double scaleFactor)
+            {
+                var dest = PInvoke.CreateRectRgn(0, 0, 0, 0);
+                //PInvoke.GetWindowRgnBox(new Windows.Win32.Foundation.HWND(_WindowHandle), dest);
+                var type = PInvoke.GetWindowRgnBox(new Windows.Win32.Foundation.HWND(_WindowHandle), out var rect);
+                return PInvoke.CreateRectRgn(rect.left, rect.top, rect.right, rect.bottom);
+                // PInvoke.InvertRgn(dest, null);
+                // return dest;
+            }
         }
 
         private class CombinedRegion : Region
@@ -54,10 +126,10 @@ public CombinedRegion(Region region1, Region region2, CombineMode mode)
                 _mode = mode;
             }
 
-            internal override HRGN Create(double scaleFactor)
+            internal override HRGN Create(ContentCoordinateConverter converter, PointInt32 screenLoc, double scaleFactor)
             {
-                var rgn1 = _region1.Create(scaleFactor);
-                var rgn2 = _region2.Create(scaleFactor);
+                var rgn1 = _region1.Create(converter, screenLoc, scaleFactor);
+                var rgn2 = _region2.Create(converter, screenLoc, scaleFactor);
 
                 var dest = PInvoke.CreateRectRgn(0, 0, 0, 0);
                 PInvoke.CombineRgn(dest, rgn1, rgn2, (RGN_COMBINE_MODE)_mode);
@@ -68,11 +140,18 @@ internal override HRGN Create(double scaleFactor)
         }
 
         /// <summary>
-        /// Creates a rectangular region.
+        /// Creates a rectangular region in device independent units.
         /// </summary>
         /// <param name="rect">Rectangular region.</param>
         /// <returns></returns>
-        public static Region Create(Rect rect) => new RectRegion(rect);
+        public static Region CreateRectangle(Rect rect) => new RectRegion(rect);
+
+        /// <summary>
+        /// Creates a rectangular region in screen units.
+        /// </summary>
+        /// <param name="rect">Rectangular region.</param>
+        /// <returns></returns>
+        public static Region CreateRectangle(RectInt32 rect) => new RectInt32Region(rect);
 
         /// <summary>
         /// Creates a rectangular region with rounded corners.
@@ -81,13 +160,48 @@ internal override HRGN Create(double scaleFactor)
         /// <param name="w">Specifies the width of the ellipse used to create the rounded corners.</param>
         /// <param name="h">Specifies the height of the ellipse used to create the rounded corners.</param>
         /// <returns></returns>
-        public static Region Create(Rect rect, double w, double h) => new RoundRectRegion(rect, w, h);
+        public static Region CreateRoundedRectangle(Rect rect, double w, double h) => new RoundRectRegion(rect, w, h);
+
+        /// <summary>
+        /// Creates an elliptical region.
+        /// </summary>
+        /// <param name="x1">Specifies the x-coordinate in device independent units, of the upper-left corner of the bounding rectangle of the ellipse.</param>
+        /// <param name="y1">Specifies the yx-coordinate in device independent units, of the upper-left corner of the bounding rectangle of the ellipse.</param>
+        /// <param name="x2">Specifies the x-coordinate in device independent units, of the lower-right corner of the bounding rectangle of the ellipse.</param>
+        /// <param name="y2">Specifies the y-coordinate in device independent units, of the lower-right corner of the bounding rectangle of the ellipse.</param>
+        /// <returns></returns>
+        public static Region CreateElliptic(double x1, double y1, double x2, double y2) => new EllipticRegion(x1, y1, x2, y2);
+
+        /// <summary>
+        /// Creates a polygonal region using alternate mode (fills area between odd-numbered and even-numbered polygon sides on each scan line).
+        /// </summary>
+        /// <param name="points">The vertices of the polygon in device independent units. The polygon is presumed closed. Each vertex can be specified only once.</param>
+        /// <returns></returns>
+        public static Region CreatePolygon(IEnumerable<Point> points) => new PolygonRegion(points, CREATE_POLYGON_RGN_MODE.ALTERNATE);
+
+        /*
+        /// <summary>
+        /// Creates a region that represents the current visible region of a window.
+        /// </summary>
+        /// <param name="window">The window to obtain the region from</param>
+        /// <returns></returns>
+        public static Region GetWindowRegion(Microsoft.UI.Xaml.Window window) => new CurrentRegion(window.GetWindowHandle());*/
 
         private Region() 
         {
         }
 
-        internal abstract HRGN Create(double scalefactor);
+        internal abstract HRGN Create(ContentCoordinateConverter converter, PointInt32 screenLoc, double scaleFactor);
+
+
+        private protected static PointInt32 Convert(double x, double y, ContentCoordinateConverter converter, PointInt32 screenLoc, double scaleFactor) => Convert(new Point(x, y), converter, screenLoc, scaleFactor);
+
+        private protected static PointInt32 Convert(Point local, ContentCoordinateConverter converter, PointInt32 screenLoc, double scaleFactor)
+        {
+            local = new Point(local.X * scaleFactor, local.Y * scaleFactor);
+            var p = converter.ConvertLocalToScreen(local);
+            return new PointInt32(p.X - screenLoc.X, p.Y - screenLoc.Y);
+        }
 
         /// <summary>
         /// The Combine function combines two regions. The two regions are combined according to the specified mode.
diff --git a/src/WinUIEx/WindowExtensions.cs b/src/WinUIEx/WindowExtensions.cs
@@ -373,8 +373,17 @@ public static void SetLayeredWindowAttributes(this Microsoft.UI.Xaml.Window wind
         /// <param name="region">The region to set on the window</param>
         public static void SetRegion(this Microsoft.UI.Xaml.Window window, Region? region)
         {
-            PInvoke.SetWindowRgn(new Windows.Win32.Foundation.HWND(window.GetWindowHandle()),
-                region?.Create(window.GetDpiForWindow() / 96d) ?? Windows.Win32.Graphics.Gdi.HRGN.Null, window.Visible);
+            var converter = Microsoft.UI.Content.ContentCoordinateConverter.CreateForWindowId(window.AppWindow.Id);
+            var screenLoc = window.AppWindow.Position;
+            var rgn = region?.Create(converter, screenLoc, window.GetDpiForWindow() / 96d) ?? Windows.Win32.Graphics.Gdi.HRGN.Null;
+            try
+            {
+                PInvoke.SetWindowRgn(new Windows.Win32.Foundation.HWND(window.GetWindowHandle()), rgn, window.Visible);
+            }
+            finally
+            {
+                PInvoke.DeleteObject(rgn);
+            }
         }
     }
 }
diff --git a/src/WinUIExSample/HoleWindow.xaml b/src/WinUIExSample/HoleWindow.xaml
@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Window
+    x:Class="WinUIExSample.HoleWindow"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:ex="using:WinUIEx"
+    xmlns:local="using:WinUIExSample"
+    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+    Title="WinUIEx Regions" 
+    mc:Ignorable="d">
+    <Grid Margin="0">
+        <Grid.RowDefinitions>
+            <RowDefinition  Height="Auto"/>
+            <RowDefinition Height="*"/>
+        </Grid.RowDefinitions>
+        <Border VerticalAlignment="Top" Background="CornflowerBlue">
+            <StackPanel Orientation="Horizontal">
+                <TextBlock Text="WinUIEx Regions" FontSize="24" FontFamily="Segoe UI" FontWeight="Light" Margin="10,5,0,5" Foreground="White" />
+                <TextBlock Text="Click blue area to punch holes in the window" Margin="20,10,0,5" Foreground="White" VerticalAlignment="Center" />
+            </StackPanel>
+        </Border>
+
+        <Canvas Grid.Row="1">
+
+            <Border Width="200" Height="200" Canvas.Left="100" Canvas.Top="50" BorderThickness="2" BorderBrush="Red" >
+                <Border Background="Blue" x:Name="RectangleArea" PointerPressed="RectangleArea_PointerPressed" />
+            </Border>
+
+            <Grid Width="200" Height="100" Canvas.Left="350" Canvas.Top="75" >
+                <Ellipse x:Name="EllipseArea" Fill="Blue" PointerPressed="EllipseArea_PointerPressed" Margin="1,1,1,1" />
+                <Ellipse Stroke="Red" StrokeThickness="2" />
+            </Grid>
+
+            <Border Width="200" Height="200" Canvas.Left="100" Canvas.Top="275" BorderThickness="2" BorderBrush="Red" CornerRadius="20" >
+                <Border Background="Blue" x:Name="RoundedRectangleArea" PointerPressed="RoundedRectangleArea_PointerPressed" CornerRadius="18" />
+            </Border>
+
+            <Grid Canvas.Left="350" Canvas.Top="275" >
+                <Path Fill="Blue" Stroke="Red" StrokeThickness="2" Data="M100,10 L122.45,72.36  L188.17,72.36  L134.86,112.9 L154.45,177.64  L100,140 L45.55,177.64 L65.14,112.9 L11.83,72.36 L77.55,72.36 Z"
+                      Stretch="None" PointerPressed="StarArea_Pressed" />
+            </Grid>
+
+        </Canvas>
+
+        <Button Content="Reset" Click="ButtonClear_Click" HorizontalAlignment="Right" VerticalAlignment="Top" Margin="20" Grid.Row="1" />
+
+    </Grid>
+</Window>
diff --git a/src/WinUIExSample/HoleWindow.xaml.cs b/src/WinUIExSample/HoleWindow.xaml.cs
@@ -0,0 +1,89 @@
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.UI.Windowing;
+using Microsoft.UI.Xaml;
+using Windows.Foundation;
+using WinUIEx;
+
+namespace WinUIExSample
+{
+    /// <summary>
+    /// An empty page that can be used on its own or navigated to within a Frame.
+    /// </summary>
+    public sealed partial class HoleWindow : Window
+    {
+        private readonly WindowManager manager;
+        public HoleWindow()
+        {
+            this.InitializeComponent();
+            ExtendsContentIntoTitleBar = true;
+            manager = WindowManager.Get(this);
+            manager.Width = 800;
+            manager.Height = 640;
+            manager.IsResizable = false; //Disable resizing for simplicity - You need to update regions on resize otherwise
+            manager.IsAlwaysOnTop = true;
+            // ((OverlappedPresenter)AppWindow.Presenter).SetBorderAndTitleBar(false, false);
+            this.Closed += HoleWindow_Closed;
+            MainWindow.Closed += MainWindow_Closed;
+        }
+
+        private void RectangleArea_PointerPressed(object sender, Microsoft.UI.Xaml.Input.PointerRoutedEventArgs e)
+        {
+            // Get the bounds of the rectangle relative to the window
+            var bounds = RectangleArea.TransformToVisual(this.Content).TransformBounds(new Rect(0, 1, RectangleArea.ActualWidth, RectangleArea.ActualHeight));
+            // Subtract the rectangle from the window region
+            var regionWithHole = GetWindowRegion() - Region.CreateRectangle(bounds);
+            this.SetRegion(regionWithHole);
+        }
+
+        private void RoundedRectangleArea_PointerPressed(object sender, Microsoft.UI.Xaml.Input.PointerRoutedEventArgs e)
+        {
+            // Get the bounds of the rectangle relative to the window
+            var bounds = RoundedRectangleArea.TransformToVisual(this.Content).TransformBounds(new Rect(1, 1, RoundedRectangleArea.ActualWidth, RoundedRectangleArea.ActualHeight));
+            // Subtract the rectangle from the window region
+            var regionWithHole = GetWindowRegion() - Region.CreateRoundedRectangle(bounds, 40, 40);
+            this.SetRegion(regionWithHole);
+        }
+
+
+        private void EllipseArea_PointerPressed(object sender, Microsoft.UI.Xaml.Input.PointerRoutedEventArgs e)
+        {
+            // Get the bounds of the ellipse relative to the window   
+            var bounds = EllipseArea.TransformToVisual(this.Content).TransformBounds(new Rect(0, 1, EllipseArea.ActualWidth, EllipseArea.ActualHeight + 1));
+            // Subtract the ellipse from the window region
+            var regionWithHole = GetWindowRegion() - Region.CreateElliptic(bounds.X, bounds.Y, bounds.Width+bounds.X, bounds.Height + bounds.Y);
+            this.SetRegion(regionWithHole);
+        }
+
+        private void ButtonClear_Click(object sender, RoutedEventArgs e) => this.SetRegion(null);
+
+        private Region GetWindowRegion()
+        {
+            return Region.CreateRoundedRectangle(new Rect(0, 1, manager.Width - 16, manager.Height - 8), 8, 8);
+        }
+
+        #region Cleanup: Ensure this window is closed when main window closes
+        private void MainWindow_Closed(object sender, WindowEventArgs args) => this.Close();
+
+        public WindowEx MainWindow => ((App)Application.Current).MainWindow!;
+
+        private void HoleWindow_Closed(object sender, WindowEventArgs args) => MainWindow.Closed -= MainWindow_Closed;
+        #endregion
+
+        private void StarArea_Pressed(object sender, Microsoft.UI.Xaml.Input.PointerRoutedEventArgs e)
+        {
+            var path = (Microsoft.UI.Xaml.Shapes.Path)sender;
+            var transformer = path.TransformToVisual(this.Content);
+            var geom = (Microsoft.UI.Xaml.Media.PathGeometry)path.Data;
+            var figure = geom.Figures[0];
+            List<Point> vertices = [transformer.TransformPoint(figure.StartPoint)];
+            foreach(var segment in figure.Segments.OfType<Microsoft.UI.Xaml.Media.LineSegment>())
+            {
+                vertices.Add(transformer.TransformPoint(segment.Point));
+            }
+            // Subtract the polygon from the window region
+            var regionWithHole = GetWindowRegion() - Region.CreatePolygon(vertices);
+            this.SetRegion(regionWithHole);
+        }
+    }
+}
diff --git a/src/WinUIExSample/Pages/WindowDesign.xaml b/src/WinUIExSample/Pages/WindowDesign.xaml
@@ -30,6 +30,7 @@
                     <ComboBoxItem>Animated</ComboBoxItem>
                     <ComboBoxItem>Blur</ComboBoxItem>
                 </ComboBox>
+                <Button Content="Open Window Hole Punch Sample" Click="OpenHoleWindow_Click" />
             </StackPanel>
         </ScrollViewer>
     </Grid>
diff --git a/src/WinUIExSample/Pages/WindowDesign.xaml.cs b/src/WinUIExSample/Pages/WindowDesign.xaml.cs
@@ -106,5 +106,10 @@ private partial class BlurredBackdrop : CompositionBrushBackdrop
             protected override Windows.UI.Composition.CompositionBrush CreateBrush(Windows.UI.Composition.Compositor compositor)
                 => compositor.CreateHostBackdropBrush();
         }
+
+        private void OpenHoleWindow_Click(object sender, RoutedEventArgs e)
+        {
+            new HoleWindow().Activate();
+        }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -373,8 +373,17 @@ public static void SetLayeredWindowAttributes(this Microsoft.UI.Xaml.Window wind`
`373`	`373`	`/// <param name="region">The region to set on the window</param>`
`374`	`374`	`public static void SetRegion(this Microsoft.UI.Xaml.Window window, Region? region)`
`375`	`375`	`{`
`376`		`- PInvoke.SetWindowRgn(new Windows.Win32.Foundation.HWND(window.GetWindowHandle()),`
`377`		`- region?.Create(window.GetDpiForWindow() / 96d) ?? Windows.Win32.Graphics.Gdi.HRGN.Null, window.Visible);`
	`376`	`+ var converter = Microsoft.UI.Content.ContentCoordinateConverter.CreateForWindowId(window.AppWindow.Id);`
	`377`	`+ var screenLoc = window.AppWindow.Position;`
	`378`	`+ var rgn = region?.Create(converter, screenLoc, window.GetDpiForWindow() / 96d) ?? Windows.Win32.Graphics.Gdi.HRGN.Null;`
	`379`	`+ try`
	`380`	`+ {`
	`381`	`+ PInvoke.SetWindowRgn(new Windows.Win32.Foundation.HWND(window.GetWindowHandle()), rgn, window.Visible);`
	`382`	`+ }`
	`383`	`+ finally`
	`384`	`+ {`
	`385`	`+ PInvoke.DeleteObject(rgn);`
	`386`	`+ }`
`378`	`387`	`}`
`379`	`388`	`}`
`380`	`389`	`}`
Original file line number	Diff line number	Diff line change
`@@ -106,5 +106,10 @@ private partial class BlurredBackdrop : CompositionBrushBackdrop`
`106`	`106`	`protected override Windows.UI.Composition.CompositionBrush CreateBrush(Windows.UI.Composition.Compositor compositor)`
`107`	`107`	`=> compositor.CreateHostBackdropBrush();`
`108`	`108`	`}`
	`109`	`+`
	`110`	`+ private void OpenHoleWindow_Click(object sender, RoutedEventArgs e)`
	`111`	`+ {`
	`112`	`+ new HoleWindow().Activate();`
	`113`	`+ }`
`109`	`114`	`}`
`110`	`115`	`}`