updated for v1.4

NSTechBytes · NSTechBytes · commit 776f90321929 · 2025-04-20T15:02:30.000+05:00
diff --git a/FinalShot/AssemblyInfo.cs b/FinalShot/AssemblyInfo.cs
@@ -2,7 +2,7 @@
 using System.Runtime.CompilerServices;
 
 [assembly: AssemblyCopyright("© 2024 - NS Tech Bytes 🇵🇰")]
-[assembly: AssemblyVersion("1.3.0.0")]
+[assembly: AssemblyVersion("1.4.0.0")]
 
 // Do not change the entries below!
 #if X64
diff --git a/FinalShot/FinalShot.cs b/FinalShot/FinalShot.cs
@@ -8,7 +8,6 @@
 
 namespace PluginScreenshot
 {
-    // Logger class for writing debug messages to a file.
     public static class Logger
     {
         public static bool DebugEnabled = false;
@@ -23,36 +22,32 @@ public static void Log(string message)
                     string logMessage = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + " " + message + Environment.NewLine;
                     File.AppendAllText(LogFilePath, logMessage);
                 }
-                catch { /* Ignore logging errors */ }
+                catch {}
             }
         }
     }
 
     internal class Measure
     {
-        private string savePath;         // Save path from the .ini file
-        private string finishAction = "";  // Action to execute after screenshot is taken
-        private Rainmeter.API api;       // Rainmeter API reference
-        public static bool showCursor; // Include cursor in the screenshot
-
-        // Predefined coordinates for -ps command.
+        private string savePath;        
+        private string finishAction = "";  
+        private Rainmeter.API api;       
+        public static bool showCursor;
         private int predefX;
         private int predefY;
         private int predefWidth;
         private int predefHeight;
 
-        // DllImport for setting thread DPI awareness context.
+
         [DllImport("user32.dll")]
         private static extern IntPtr SetThreadDpiAwarenessContext(IntPtr dpiContext);
         private static readonly IntPtr DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2 = new IntPtr(-4);
 
-        // DllImport for getting cursor information and drawing the cursor.
         [DllImport("user32.dll")]
         private static extern bool GetCursorInfo(out CURSORINFO pci);
         [DllImport("user32.dll")]
         private static extern bool DrawIcon(IntPtr hDC, int X, int Y, IntPtr hIcon);
 
-        // Structs for cursor information.
         [StructLayout(LayoutKind.Sequential)]
         private struct POINT { public int x, y; }
         [StructLayout(LayoutKind.Sequential)]
@@ -63,7 +58,6 @@ private struct CURSORINFO
             public POINT ptScreenPos;
         }
 
-        // Constant for cursor information.
         private const int CURSOR_SHOWING = 0x00000001;
 
         public Measure(Rainmeter.API api)
@@ -73,17 +67,13 @@ public Measure(Rainmeter.API api)
 
         public void Reload(Rainmeter.API api, ref double maxValue)
         {
-            // Read configuration from the .ini file.
             savePath = api.ReadString("SavePath", "");
             finishAction = api.ReadString("ScreenshotFinishAction", "");
             showCursor = api.ReadInt("ShowCursor", 0) > 0;
-
             predefX = api.ReadInt("PredefX", 0);
             predefY = api.ReadInt("PredefY", 0);
             predefWidth = api.ReadInt("PredefWidth", 0);
             predefHeight = api.ReadInt("PredefHeight", 0);
-
-            // Read debugging options.
             bool debugEnabled = api.ReadInt("DebugLog", 0) == 1;
             Logger.DebugEnabled = debugEnabled;
             string debugPath = api.ReadString("DebugLogPath", "");
@@ -93,7 +83,6 @@ public void Reload(Rainmeter.API api, ref double maxValue)
             Logger.Log("Reload complete. SavePath: " + savePath);
         }
 
-        // Helper: Draw the cursor on the screenshot.
         public static void DrawCursor(Graphics g, Rectangle bounds)
         {
             var ci = new CURSORINFO { cbSize = Marshal.SizeOf(typeof(CURSORINFO)) };
@@ -108,7 +97,6 @@ public static void DrawCursor(Graphics g, Rectangle bounds)
             }
         }
 
-        // Helper: Run code in a DPI-aware thread context.
         private void RunWithHighDpiContext(Action action)
         {
             IntPtr oldContext = SetThreadDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
@@ -138,7 +126,6 @@ private void TakeScreenshot()
 
             RunWithHighDpiContext(() =>
             {
-                // Capture the entire virtual screen.
                 Rectangle bounds = SystemInformation.VirtualScreen;
                 Logger.Log("Full screenshot bounds: " + bounds);
                 using (Bitmap bitmap = new Bitmap(bounds.Width, bounds.Height))
@@ -164,7 +151,6 @@ private void TakeCustomScreenshot()
                 return;
             }
             Logger.Log("Launching custom screenshot form.");
-            // Launch the custom screenshot form.
             Application.Run(new CustomScreenshotForm(savePath, ExecuteFinishAction));
         }
 
@@ -224,38 +210,32 @@ private void ExecuteFinishAction()
         }
     }
 
-    // Custom screenshot form – now DPI aware so that mouse events report physical coordinates.
-    // This version attempts to handle multi-monitor selections with different DPI by compositing portions.
     public class CustomScreenshotForm : Form
     {
-        private Point startPoint;      // Physical coordinates where mouse is pressed.
-        private Rectangle selection;   // Rectangle defined by the drag (in client coordinates).
+        private Point startPoint;      
+        private Rectangle selection;   
         private string savePath;
         private bool isSelecting;
         private Action finishAction;
 
-        // DllImport for setting thread DPI awareness.
         [DllImport("user32.dll")]
         private static extern IntPtr SetThreadDpiAwarenessContext(IntPtr dpiContext);
         private static readonly IntPtr DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2 = new IntPtr(-4);
 
         public CustomScreenshotForm(string savePath, Action finishAction)
         {
-            // Set thread DPI awareness so that mouse events are in physical pixels.
             SetThreadDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
 
             this.savePath = savePath;
             this.finishAction = finishAction;
             this.DoubleBuffered = true;
             this.FormBorderStyle = FormBorderStyle.None;
-            // Cover the entire virtual screen.
             this.Bounds = SystemInformation.VirtualScreen;
             this.BackColor = Color.Black;
             this.Opacity = 0.25;
             this.TopMost = true;
             this.Cursor = Cursors.Cross;
             this.StartPosition = FormStartPosition.Manual;
-            // Position the form at the virtual screen's top-left.
             this.Location = SystemInformation.VirtualScreen.Location;
 
             this.MouseDown += OnMouseDown;
@@ -268,7 +248,6 @@ public CustomScreenshotForm(string savePath, Action finishAction)
 
         private void OnMouseDown(object sender, MouseEventArgs e)
         {
-            // With DPI awareness enabled, e.Location is in physical pixels.
             startPoint = e.Location;
             isSelecting = true;
             Logger.Log("Custom screenshot started at: " + startPoint);
@@ -278,7 +257,6 @@ private void OnMouseMove(object sender, MouseEventArgs e)
         {
             if (isSelecting)
             {
-                // Update selection rectangle based on current mouse position.
                 int x = Math.Min(startPoint.X, e.X);
                 int y = Math.Min(startPoint.Y, e.Y);
                 int width = Math.Abs(startPoint.X - e.X);
@@ -299,7 +277,6 @@ private void OnMouseUp(object sender, MouseEventArgs e)
                 return;
             }
             this.Hide();
-            // Calculate the capture rectangle in absolute physical coordinates.
             Rectangle captureRect = new Rectangle(
                 this.Bounds.Left + selection.X,
                 this.Bounds.Top + selection.Y,
@@ -314,8 +291,7 @@ private void OnPaint(object sender, PaintEventArgs e)
         {
             if (isSelecting)
             {
-                // Draw only a bold dashed rectangle (no fill).
-                using (Pen borderPen = new Pen(Color.Red, 3))
+                using (Pen borderPen = new Pen(Color.Blue, 3))
                 {
                     borderPen.DashStyle = System.Drawing.Drawing2D.DashStyle.Dash;
                     e.Graphics.DrawRectangle(borderPen, selection);
@@ -326,11 +302,9 @@ private void OnPaint(object sender, PaintEventArgs e)
         private void TakeScreenshot(Rectangle captureRect)
         {
             Logger.Log("Taking screenshot from rectangle: " + captureRect);
-            // Check if the captureRect is completely contained in one monitor.
             bool isContained = false;
             foreach (Screen screen in Screen.AllScreens)
             {
-                // Use screen.Bounds which should be in physical pixels for a DPI-aware process.
                 if (screen.Bounds.Contains(captureRect))
                 {
                     isContained = true;
@@ -340,13 +314,11 @@ private void TakeScreenshot(Rectangle captureRect)
 
             if (isContained)
             {
-                // Single-capture mode.
                 Logger.Log("Capture rectangle contained in one monitor; using single capture.");
                 TakeSingleCapture(captureRect);
             }
             else
             {
-                // Composite capture mode: the selection spans multiple monitors.
                 Logger.Log("Capture rectangle spans multiple monitors; composing capture from parts.");
                 TakeCompositeCapture(captureRect);
             }
@@ -355,7 +327,6 @@ private void TakeScreenshot(Rectangle captureRect)
 
         private void TakeSingleCapture(Rectangle rect)
         {
-            // Use DPI-aware context for capturing.
             IntPtr oldContext = SetThreadDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
             try
             {
@@ -378,18 +349,15 @@ private void TakeSingleCapture(Rectangle rect)
 
         private void TakeCompositeCapture(Rectangle rect)
         {
-            // Create a final composite bitmap of the entire selection.
             Bitmap finalBitmap = new Bitmap(rect.Width, rect.Height);
             using (Graphics finalGraphics = Graphics.FromImage(finalBitmap))
             {
-                // Iterate over all screens and capture the intersections.
                 foreach (Screen screen in Screen.AllScreens)
                 {
                     Rectangle intersect = Rectangle.Intersect(rect, screen.Bounds);
                     if (intersect.Width > 0 && intersect.Height > 0)
                     {
                         Logger.Log("Capturing intersection with screen (" + screen.DeviceName + "): " + intersect);
-                        // Capture this sub-region.
                         using (Bitmap part = new Bitmap(intersect.Width, intersect.Height))
                         {
                             using (Graphics g = Graphics.FromImage(part))
@@ -398,7 +366,6 @@ private void TakeCompositeCapture(Rectangle rect)
                                 if (Measure.showCursor)
                                     Measure.DrawCursor(finalGraphics, rect);
                             }
-                            // Draw this part into the final composite image.
                             finalGraphics.DrawImage(part, new Rectangle(intersect.Left - rect.Left, intersect.Top - rect.Top, intersect.Width, intersect.Height));
                         }
                     }
@@ -436,14 +403,13 @@ private ImageFormat GetImageFormat(string path)
                 case ".tiff":
                     return ImageFormat.Tiff;
                 default:
-                    return ImageFormat.Png; // fallback
+                    return ImageFormat.Png; 
             }
         }
     }
 
     public static class Plugin
     {
-        // Do not mark the entire process as DPI aware to avoid affecting Rainmeter's UI.
         [DllExport]
         public static void Initialize(ref IntPtr data, IntPtr rm)
         {
diff --git a/README.md b/README.md
@@ -57,13 +57,16 @@ Define a measure that loads the plugin and configures the screenshot options:
 [MeasureScreenshot]
 Measure=Plugin
 Plugin=FinalShot
+;!Note supported Image extension are .png(default),jpg,.jpeg,.tiff,.bmp.
 SavePath=#@#Screenshots\screenshot.png
 PredefX=100
 PredefY=100
 PredefWidth=400
 PredefHeight=300
 DebugLog=1
 DebugLogPath=#@#FinalShotDebug.log
+;Capture Mouse Cursor in Screenshot.
+ShowCursor=1
 ```
 
 ### 📸 **Screenshot Modes:**  

Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,6 @@`
`8`	`8`
`9`	`9`	`namespace PluginScreenshot`
`10`	`10`	`{`
`11`		`- // Logger class for writing debug messages to a file.`
`12`	`11`	`public static class Logger`
`13`	`12`	`{`
`14`	`13`	`public static bool DebugEnabled = false;`
`@@ -23,36 +22,32 @@ public static void Log(string message)`
`23`	`22`	`string logMessage = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + " " + message + Environment.NewLine;`
`24`	`23`	`File.AppendAllText(LogFilePath, logMessage);`
`25`	`24`	`}`
`26`		`- catch { /* Ignore logging errors */ }`
	`25`	`+ catch {}`
`27`	`26`	`}`
`28`	`27`	`}`
`29`	`28`	`}`
`30`	`29`
`31`	`30`	`internal class Measure`
`32`	`31`	`{`
`33`		`- private string savePath; // Save path from the .ini file`
`34`		`- private string finishAction = ""; // Action to execute after screenshot is taken`
`35`		`- private Rainmeter.API api; // Rainmeter API reference`
`36`		`- public static bool showCursor; // Include cursor in the screenshot`
`37`		`-`
`38`		`- // Predefined coordinates for -ps command.`
	`32`	`+ private string savePath;`
	`33`	`+ private string finishAction = "";`
	`34`	`+ private Rainmeter.API api;`
	`35`	`+ public static bool showCursor;`
`39`	`36`	`private int predefX;`
`40`	`37`	`private int predefY;`
`41`	`38`	`private int predefWidth;`
`42`	`39`	`private int predefHeight;`
`43`	`40`
`44`		`- // DllImport for setting thread DPI awareness context.`
	`41`	`+`
`45`	`42`	`[DllImport("user32.dll")]`
`46`	`43`	`private static extern IntPtr SetThreadDpiAwarenessContext(IntPtr dpiContext);`
`47`	`44`	`private static readonly IntPtr DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2 = new IntPtr(-4);`
`48`	`45`
`49`		`- // DllImport for getting cursor information and drawing the cursor.`
`50`	`46`	`[DllImport("user32.dll")]`
`51`	`47`	`private static extern bool GetCursorInfo(out CURSORINFO pci);`
`52`	`48`	`[DllImport("user32.dll")]`
`53`	`49`	`private static extern bool DrawIcon(IntPtr hDC, int X, int Y, IntPtr hIcon);`
`54`	`50`
`55`		`- // Structs for cursor information.`
`56`	`51`	`[StructLayout(LayoutKind.Sequential)]`
`57`	`52`	`private struct POINT { public int x, y; }`
`58`	`53`	`[StructLayout(LayoutKind.Sequential)]`
`@@ -63,7 +58,6 @@ private struct CURSORINFO`
`63`	`58`	`public POINT ptScreenPos;`
`64`	`59`	`}`
`65`	`60`
`66`		`- // Constant for cursor information.`
`67`	`61`	`private const int CURSOR_SHOWING = 0x00000001;`
`68`	`62`
`69`	`63`	`public Measure(Rainmeter.API api)`
`@@ -73,17 +67,13 @@ public Measure(Rainmeter.API api)`
`73`	`67`
`74`	`68`	`public void Reload(Rainmeter.API api, ref double maxValue)`
`75`	`69`	`{`
`76`		`- // Read configuration from the .ini file.`
`77`	`70`	`savePath = api.ReadString("SavePath", "");`
`78`	`71`	`finishAction = api.ReadString("ScreenshotFinishAction", "");`
`79`	`72`	`showCursor = api.ReadInt("ShowCursor", 0) > 0;`
`80`		`-`
`81`	`73`	`predefX = api.ReadInt("PredefX", 0);`
`82`	`74`	`predefY = api.ReadInt("PredefY", 0);`
`83`	`75`	`predefWidth = api.ReadInt("PredefWidth", 0);`
`84`	`76`	`predefHeight = api.ReadInt("PredefHeight", 0);`
`85`		`-`
`86`		`- // Read debugging options.`
`87`	`77`	`bool debugEnabled = api.ReadInt("DebugLog", 0) == 1;`
`88`	`78`	`Logger.DebugEnabled = debugEnabled;`
`89`	`79`	`string debugPath = api.ReadString("DebugLogPath", "");`
`@@ -93,7 +83,6 @@ public void Reload(Rainmeter.API api, ref double maxValue)`
`93`	`83`	`Logger.Log("Reload complete. SavePath: " + savePath);`
`94`	`84`	`}`
`95`	`85`
`96`		`- // Helper: Draw the cursor on the screenshot.`
`97`	`86`	`public static void DrawCursor(Graphics g, Rectangle bounds)`
`98`	`87`	`{`
`99`	`88`	`var ci = new CURSORINFO { cbSize = Marshal.SizeOf(typeof(CURSORINFO)) };`
`@@ -108,7 +97,6 @@ public static void DrawCursor(Graphics g, Rectangle bounds)`
`108`	`97`	`}`
`109`	`98`	`}`
`110`	`99`
`111`		`- // Helper: Run code in a DPI-aware thread context.`
`112`	`100`	`private void RunWithHighDpiContext(Action action)`
`113`	`101`	`{`
`114`	`102`	`IntPtr oldContext = SetThreadDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);`
`@@ -138,7 +126,6 @@ private void TakeScreenshot()`
`138`	`126`
`139`	`127`	`RunWithHighDpiContext(() =>`
`140`	`128`	`{`
`141`		`- // Capture the entire virtual screen.`
`142`	`129`	`Rectangle bounds = SystemInformation.VirtualScreen;`
`143`	`130`	`Logger.Log("Full screenshot bounds: " + bounds);`
`144`	`131`	`using (Bitmap bitmap = new Bitmap(bounds.Width, bounds.Height))`
`@@ -164,7 +151,6 @@ private void TakeCustomScreenshot()`
`164`	`151`	`return;`
`165`	`152`	`}`
`166`	`153`	`Logger.Log("Launching custom screenshot form.");`
`167`		`- // Launch the custom screenshot form.`
`168`	`154`	`Application.Run(new CustomScreenshotForm(savePath, ExecuteFinishAction));`
`169`	`155`	`}`
`170`	`156`
`@@ -224,38 +210,32 @@ private void ExecuteFinishAction()`
`224`	`210`	`}`
`225`	`211`	`}`
`226`	`212`
`227`		`- // Custom screenshot form – now DPI aware so that mouse events report physical coordinates.`
`228`		`- // This version attempts to handle multi-monitor selections with different DPI by compositing portions.`
`229`	`213`	`public class CustomScreenshotForm : Form`
`230`	`214`	`{`
`231`		`- private Point startPoint; // Physical coordinates where mouse is pressed.`
`232`		`- private Rectangle selection; // Rectangle defined by the drag (in client coordinates).`
	`215`	`+ private Point startPoint;`
	`216`	`+ private Rectangle selection;`
`233`	`217`	`private string savePath;`
`234`	`218`	`private bool isSelecting;`
`235`	`219`	`private Action finishAction;`
`236`	`220`
`237`		`- // DllImport for setting thread DPI awareness.`
`238`	`221`	`[DllImport("user32.dll")]`
`239`	`222`	`private static extern IntPtr SetThreadDpiAwarenessContext(IntPtr dpiContext);`
`240`	`223`	`private static readonly IntPtr DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2 = new IntPtr(-4);`
`241`	`224`
`242`	`225`	`public CustomScreenshotForm(string savePath, Action finishAction)`
`243`	`226`	`{`
`244`		`- // Set thread DPI awareness so that mouse events are in physical pixels.`
`245`	`227`	`SetThreadDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);`
`246`	`228`
`247`	`229`	`this.savePath = savePath;`
`248`	`230`	`this.finishAction = finishAction;`
`249`	`231`	`this.DoubleBuffered = true;`
`250`	`232`	`this.FormBorderStyle = FormBorderStyle.None;`
`251`		`- // Cover the entire virtual screen.`
`252`	`233`	`this.Bounds = SystemInformation.VirtualScreen;`
`253`	`234`	`this.BackColor = Color.Black;`
`254`	`235`	`this.Opacity = 0.25;`
`255`	`236`	`this.TopMost = true;`
`256`	`237`	`this.Cursor = Cursors.Cross;`
`257`	`238`	`this.StartPosition = FormStartPosition.Manual;`
`258`		`- // Position the form at the virtual screen's top-left.`
`259`	`239`	`this.Location = SystemInformation.VirtualScreen.Location;`
`260`	`240`
`261`	`241`	`this.MouseDown += OnMouseDown;`
`@@ -268,7 +248,6 @@ public CustomScreenshotForm(string savePath, Action finishAction)`
`268`	`248`
`269`	`249`	`private void OnMouseDown(object sender, MouseEventArgs e)`
`270`	`250`	`{`
`271`		`- // With DPI awareness enabled, e.Location is in physical pixels.`
`272`	`251`	`startPoint = e.Location;`
`273`	`252`	`isSelecting = true;`
`274`	`253`	`Logger.Log("Custom screenshot started at: " + startPoint);`
`@@ -278,7 +257,6 @@ private void OnMouseMove(object sender, MouseEventArgs e)`
`278`	`257`	`{`
`279`	`258`	`if (isSelecting)`
`280`	`259`	`{`
`281`		`- // Update selection rectangle based on current mouse position.`
`282`	`260`	`int x = Math.Min(startPoint.X, e.X);`
`283`	`261`	`int y = Math.Min(startPoint.Y, e.Y);`
`284`	`262`	`int width = Math.Abs(startPoint.X - e.X);`
`@@ -299,7 +277,6 @@ private void OnMouseUp(object sender, MouseEventArgs e)`
`299`	`277`	`return;`
`300`	`278`	`}`
`301`	`279`	`this.Hide();`
`302`		`- // Calculate the capture rectangle in absolute physical coordinates.`
`303`	`280`	`Rectangle captureRect = new Rectangle(`
`304`	`281`	`this.Bounds.Left + selection.X,`
`305`	`282`	`this.Bounds.Top + selection.Y,`
`@@ -314,8 +291,7 @@ private void OnPaint(object sender, PaintEventArgs e)`
`314`	`291`	`{`
`315`	`292`	`if (isSelecting)`
`316`	`293`	`{`
`317`		`- // Draw only a bold dashed rectangle (no fill).`
`318`		`- using (Pen borderPen = new Pen(Color.Red, 3))`
	`294`	`+ using (Pen borderPen = new Pen(Color.Blue, 3))`
`319`	`295`	`{`
`320`	`296`	`borderPen.DashStyle = System.Drawing.Drawing2D.DashStyle.Dash;`
`321`	`297`	`e.Graphics.DrawRectangle(borderPen, selection);`
`@@ -326,11 +302,9 @@ private void OnPaint(object sender, PaintEventArgs e)`
`326`	`302`	`private void TakeScreenshot(Rectangle captureRect)`
`327`	`303`	`{`
`328`	`304`	`Logger.Log("Taking screenshot from rectangle: " + captureRect);`
`329`		`- // Check if the captureRect is completely contained in one monitor.`
`330`	`305`	`bool isContained = false;`
`331`	`306`	`foreach (Screen screen in Screen.AllScreens)`
`332`	`307`	`{`
`333`		`- // Use screen.Bounds which should be in physical pixels for a DPI-aware process.`
`334`	`308`	`if (screen.Bounds.Contains(captureRect))`
`335`	`309`	`{`
`336`	`310`	`isContained = true;`
`@@ -340,13 +314,11 @@ private void TakeScreenshot(Rectangle captureRect)`
`340`	`314`
`341`	`315`	`if (isContained)`
`342`	`316`	`{`
`343`		`- // Single-capture mode.`
`344`	`317`	`Logger.Log("Capture rectangle contained in one monitor; using single capture.");`
`345`	`318`	`TakeSingleCapture(captureRect);`
`346`	`319`	`}`
`347`	`320`	`else`
`348`	`321`	`{`
`349`		`- // Composite capture mode: the selection spans multiple monitors.`
`350`	`322`	`Logger.Log("Capture rectangle spans multiple monitors; composing capture from parts.");`
`351`	`323`	`TakeCompositeCapture(captureRect);`
`352`	`324`	`}`
`@@ -355,7 +327,6 @@ private void TakeScreenshot(Rectangle captureRect)`
`355`	`327`
`356`	`328`	`private void TakeSingleCapture(Rectangle rect)`
`357`	`329`	`{`
`358`		`- // Use DPI-aware context for capturing.`
`359`	`330`	`IntPtr oldContext = SetThreadDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);`
`360`	`331`	`try`
`361`	`332`	`{`
`@@ -378,18 +349,15 @@ private void TakeSingleCapture(Rectangle rect)`
`378`	`349`
`379`	`350`	`private void TakeCompositeCapture(Rectangle rect)`
`380`	`351`	`{`
`381`		`- // Create a final composite bitmap of the entire selection.`
`382`	`352`	`Bitmap finalBitmap = new Bitmap(rect.Width, rect.Height);`
`383`	`353`	`using (Graphics finalGraphics = Graphics.FromImage(finalBitmap))`
`384`	`354`	`{`
`385`		`- // Iterate over all screens and capture the intersections.`
`386`	`355`	`foreach (Screen screen in Screen.AllScreens)`
`387`	`356`	`{`
`388`	`357`	`Rectangle intersect = Rectangle.Intersect(rect, screen.Bounds);`
`389`	`358`	`if (intersect.Width > 0 && intersect.Height > 0)`
`390`	`359`	`{`
`391`	`360`	`Logger.Log("Capturing intersection with screen (" + screen.DeviceName + "): " + intersect);`
`392`		`- // Capture this sub-region.`
`393`	`361`	`using (Bitmap part = new Bitmap(intersect.Width, intersect.Height))`
`394`	`362`	`{`
`395`	`363`	`using (Graphics g = Graphics.FromImage(part))`
`@@ -398,7 +366,6 @@ private void TakeCompositeCapture(Rectangle rect)`
`398`	`366`	`if (Measure.showCursor)`
`399`	`367`	`Measure.DrawCursor(finalGraphics, rect);`
`400`	`368`	`}`
`401`		`- // Draw this part into the final composite image.`
`402`	`369`	`finalGraphics.DrawImage(part, new Rectangle(intersect.Left - rect.Left, intersect.Top - rect.Top, intersect.Width, intersect.Height));`
`403`	`370`	`}`
`404`	`371`	`}`
`@@ -436,14 +403,13 @@ private ImageFormat GetImageFormat(string path)`
`436`	`403`	`case ".tiff":`
`437`	`404`	`return ImageFormat.Tiff;`
`438`	`405`	`default:`
`439`		`- return ImageFormat.Png; // fallback`
	`406`	`+ return ImageFormat.Png;`
`440`	`407`	`}`
`441`	`408`	`}`
`442`	`409`	`}`
`443`	`410`
`444`	`411`	`public static class Plugin`
`445`	`412`	`{`
`446`		`- // Do not mark the entire process as DPI aware to avoid affecting Rainmeter's UI.`
`447`	`413`	`[DllExport]`
`448`	`414`	`public static void Initialize(ref IntPtr data, IntPtr rm)`
`449`	`415`	`{`