fix(Core): trim Linux OpenGL info from NVIDIA Driver Version

BrycensRanch · BrycensRanch · commit 0ef6896da6e5 · 2025-10-03T08:57:25.000-04:00
diff --git a/SnapX.Core/Utils/OsInfo.cs b/SnapX.Core/Utils/OsInfo.cs
@@ -3,6 +3,7 @@
 using System.Runtime.InteropServices;
 using System.Runtime.Versioning;
 using System.Text.RegularExpressions;
+using SixLabors.ImageSharp;
 #if WINDOWS
 using SnapX.Core.Utils.Native;
 using Windows.Win32.System.SystemInformation;
@@ -16,25 +17,26 @@ namespace SnapX.Core.Utils;
 
 public static partial class OsInfo
 {
+#if WINDOWS
     public record WindowsGpuInfo(string Description, string DriverVersion);
-    public record WindowsMonitorInfo(string Name, string Position, string Resolution);
+    public record WindowsMonitorInfo(string Name, Point Position, string Resolution);
     public record WindowsGraphicsInfo(List<WindowsGpuInfo> Gpus, List<WindowsMonitorInfo> Monitors);
-
+#endif
     public record LinuxGpuInfo(string Description, string Vendor, string DriverVersion);
-    public record LinuxMonitorInfo(string Name, string Resolution, string Coordinates);
+    public record LinuxMonitorInfo(string Name, string Resolution, Point Coordinates);
     public record LinuxGraphicsInfo(List<LinuxGpuInfo>? Gpus, List<LinuxMonitorInfo> Monitors);
 
     public record MacOSGraphicsInfo(string GpuChipset, string GpuDriverVersion, string MonitorResolution);
     public record GenericGpuInfo(string Description, string DriverVersion, string? Vendor = null);
-    public record GenericMonitorInfo(string Name, string Resolution, string? Position = null)
+    public record GenericMonitorInfo(string Name, string Resolution, Point? Position = null)
     {
         public override string ToString() =>
             Position is not null
                 ? $"{Name} [{Resolution} @ {Position}]"
                 : $"{Name} [{Resolution}]";
     }
     public record GenericGraphicsInfo(List<GenericGpuInfo>? Gpus, List<GenericMonitorInfo>? Monitors, string OperatingSystemName, string? ErrorMessage = null);
-
+#if WINDOWS
     private static readonly Dictionary<string, string> BuildToFriendlyName = new()
     {
         // Windows 11
@@ -61,6 +63,7 @@ public record GenericGraphicsInfo(List<GenericGpuInfo>? Gpus, List<GenericMonito
         { "19044", "21H2" },
         { "19045", "22H2" }
     };
+#endif
     public static string GetFancyOSNameAndVersion()
     {
         if (OperatingSystem.IsWindows()) return GetWindowsVersion();
@@ -218,7 +221,7 @@ private static string GetProcessorNameLinux()
             foreach (var line in lines)
             {
                 if (!line.StartsWith("model name")) continue;
-                var processorName = line[(line.IndexOf(":") + 2)..].Trim();
+                var processorName = line[(line.IndexOf(':') + 2)..].Trim();
                 return processorName;
             }
         }
@@ -294,10 +297,10 @@ public static (long totalMemory, long usedMemory) GetMemoryInfo()
 
         return (0, 0);
     }
+#if WINDOWS
     [SupportedOSPlatform("windows5.1.2600")]
     private static (long totalMemory, long usedMemory) GetMemoryInfoWindows()
     {
-#if WINDOWS
         try
         {
             var status = new MEMORYSTATUSEX
@@ -320,13 +323,11 @@ private static (long totalMemory, long usedMemory) GetMemoryInfoWindows()
         {
             DebugHelper.WriteException("Error reading memory info on Windows: " + ex.Message);
         }
-#endif
         return (0, 0);
     }
     [SupportedOSPlatform("windows5.1.2600")]
     private static long GetAvailableMemoryWindows()
     {
-#if WINDOWS
         var status = new MEMORYSTATUSEX
         {
             dwLength = (uint)Marshal.SizeOf(typeof(MEMORYSTATUSEX))
@@ -337,9 +338,9 @@ private static long GetAvailableMemoryWindows()
             return (long)status.ullAvailPhys;
         }
         DebugHelper.WriteException(new Exception("Unable to retrieve memory information."));
-#endif
         return -1;
     }
+#endif
     [SupportedOSPlatform("linux")]
     private static (long totalMemory, long usedMemory) GetMemoryInfoLinux()
     {
@@ -501,13 +502,17 @@ public static GenericGraphicsInfo GetGenericGraphicsInfo()
     {
         if (OperatingSystem.IsWindows())
         {
+#if WINDOWS
             var windowsInfo = GetGraphicsInfoWindows();
             if (windowsInfo == null)
                 return new GenericGraphicsInfo([], [], "Windows",
                     "Error retrieving Windows graphics info.");
             var genericGpus = windowsInfo.Gpus.Select(g => new GenericGpuInfo(g.Description, g.DriverVersion)).ToList();
             var genericMonitors = windowsInfo.Monitors.Select(m => new GenericMonitorInfo(m.Name, m.Resolution, m.Position)).ToList();
             return new GenericGraphicsInfo(genericGpus, genericMonitors, "Windows");
+#else
+            return new GenericGraphicsInfo([], [], "Windows", "Compilation error for Windows specific code not being included??");
+#endif
         }
         else
         {
@@ -546,10 +551,10 @@ public static GenericGraphicsInfo GetGenericGraphicsInfo()
             return new GenericGraphicsInfo(genericGpusmacOS, genericMonitors, "macOS");
         }
     }
+#if WINDOWS
     [SupportedOSPlatform("windows")]
     public static WindowsGraphicsInfo? GetGraphicsInfoWindows()
     {
-#if WINDOWS
         try
         {
             const string gpuCommand = """
@@ -610,22 +615,63 @@ public static GenericGraphicsInfo GetGenericGraphicsInfo()
         {
             return null;
         }
-#else
-        return null;
-#endif
     }
     private static List<WindowsGpuInfo> ParseWindowsGpuInfo(string rawOutput)
     {
         var lines = rawOutput.Trim().Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries);
         var regex = WindowsGPUInfoRegex();
         return (from line in lines select line.Trim() into trimmedLine select regex.Match(trimmedLine) into match where match.Success let name = match.Groups[1].Value.Trim() let driver = match.Groups[2].Value.Trim() select new WindowsGpuInfo(name, driver)).ToList();
     }
-
     private static List<WindowsMonitorInfo> ParseWindowsMonitorInfo(string rawOutput)
     {
         var lines = rawOutput.Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries);
-        return (from line in lines where line.StartsWith("Monitor:") select line["Monitor: ".Length..].Split([", Position: ", ", Resolution: "], StringSplitOptions.RemoveEmptyEntries) into parts where parts.Length == 3 let name = parts[0] let positionPart = parts[1] let resolutionPart = parts[2] select new WindowsMonitorInfo(name, positionPart, resolutionPart)).ToList();
+        return (from line in lines where line.StartsWith("Monitor:") select line["Monitor: ".Length..].Split([", Position: ", ", Resolution: "], StringSplitOptions.RemoveEmptyEntries) into parts where parts.Length == 3 let name = parts[0] let positionPart = parts[1] let resolutionPart = parts[2] select new WindowsMonitorInfo(name, ParsePosition(positionPart), resolutionPart)).ToList();
+    }
+    public static Point ParsePosition(string position)
+    {
+        if (string.IsNullOrWhiteSpace(position))
+            return new Point(0, 0);
+
+        try
+        {
+            // Remove surrounding parentheses if present
+            position = position.Trim();
+            if (position.StartsWith("(") && position.EndsWith(")"))
+            {
+                position = position.Substring(1, position.Length - 2).Trim();
+            }
+
+            // Expected format after trimming: "X: 0, Y: 0"
+            var parts = position.Split(',');
+            int x = 0, y = 0;
+
+            foreach (var part in parts)
+            {
+                var kv = part.Split(':');
+                if (kv.Length != 2) continue;
+
+                var key = kv[0].Trim().ToUpperInvariant();
+                var value = int.Parse(kv[1].Trim());
+
+                switch (key)
+                {
+                    case "X":
+                        x = value;
+                        break;
+                    case "Y":
+                        y = value;
+                        break;
+                }
+            }
+
+            return new Point(x, y);
+        }
+        catch
+        {
+            return new Point(0, 0); // fallback if parsing fails
+        }
     }
+#endif
     public static LinuxGraphicsInfo? GetGraphicsInfoLinux()
     {
         try
@@ -658,9 +704,9 @@ private static List<WindowsMonitorInfo> ParseWindowsMonitorInfo(string rawOutput
                 var glxLines = glxInfo.Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries);
                 if (string.IsNullOrWhiteSpace(driverVersion))
                 {
-                    driverVersion = glxLines.FirstOrDefault(line => line.Contains("OpenGL version"))?.Split(':')[1]?.Trim();
+                    driverVersion = glxLines.FirstOrDefault(glxLine => glxLine.Contains("OpenGL version"))?.Split(':')[1]?.Trim();
                     var mesaRegex = MesaRegex();
-                    var versionLine = glxLines.FirstOrDefault(line => line.Contains("OpenGL version"));
+                    var versionLine = glxLines.FirstOrDefault(glxLine => glxLine.Contains("OpenGL version"));
                     var mesaMatch = mesaRegex.Match(versionLine ?? string.Empty);
                     if (mesaMatch.Success)
                         driverVersion = mesaMatch.Value;
@@ -669,6 +715,10 @@ private static List<WindowsMonitorInfo> ParseWindowsMonitorInfo(string rawOutput
                     {
                         driverVersion = $"Kernel {kernelVersion} {driverVersion}";
                     }
+                    else if (driverVersion?.Contains("NVIDIA", StringComparison.InvariantCultureIgnoreCase) ?? false)
+                    {
+                        driverVersion = driverVersion?.Split(' ').Last();
+                    }
                 }
                 var vendor = glxLines.FirstOrDefault(line => line.Contains("OpenGL vendor string"))?.Split(':')[1]?.Trim();
                 gpuInfoList.Add(new LinuxGpuInfo(gpu, vendor, driverVersion));
@@ -700,11 +750,10 @@ private static List<WindowsMonitorInfo> ParseWindowsMonitorInfo(string rawOutput
                     }
 
                     var coordinateParts = resolutionAndCoords.Split('+');
-                    var x = coordinateParts.Length > 1 ? coordinateParts[1] : string.Empty;
-                    var y = coordinateParts.Length > 2 ? coordinateParts[2] : string.Empty;
-                    var coordinates = $"({x}, {y})";
+                    var x = int.Parse(coordinateParts.Length > 1 ? coordinateParts[1] : string.Empty);
+                    var y = int.Parse(coordinateParts.Length > 2 ? coordinateParts[2] : string.Empty);
 
-                    monitors.Add(new LinuxMonitorInfo(monitorName, resolution, coordinates));
+                    monitors.Add(new LinuxMonitorInfo(monitorName, resolution, new Point(x, y)));
                 }
             }
             catch (Exception ex)
@@ -779,7 +828,6 @@ public static bool IsHdrSupported()
         // If they're on Linux, they should know they're using things like HDR.
     }
 
-    [SupportedOSPlatform("linux")]
     public static bool IsWSL()
     {
         if (!OperatingSystem.IsLinux()) return false;
@@ -793,18 +841,15 @@ public static bool IsWSL()
             return false;
         }
     }
+#if WINDOWS
     [SupportedOSPlatform("windows5.0")]
     private static bool CheckWindowsHdr()
     {
-#if WINDOWS
         var hdc = PInvoke.GetDC(new HWND(IntPtr.Zero));
         var bpp = PInvoke.GetDeviceCaps(hdc, GET_DEVICE_CAPS_INDEX.BITSPIXEL);
         return bpp >= 30;
-#else
-        return false;
-#endif
     }
-
+#endif
     private static bool CheckMacOSHdr()
     {
         var displayInfo = GetMacOSDisplayInfo();

Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@`
`3`	`3`	`using System.Runtime.InteropServices;`
`4`	`4`	`using System.Runtime.Versioning;`
`5`	`5`	`using System.Text.RegularExpressions;`
	`6`	`+using SixLabors.ImageSharp;`
`6`	`7`	`#if WINDOWS`
`7`	`8`	`using SnapX.Core.Utils.Native;`
`8`	`9`	`using Windows.Win32.System.SystemInformation;`
`@@ -16,25 +17,26 @@ namespace SnapX.Core.Utils;`
`16`	`17`
`17`	`18`	`public static partial class OsInfo`
`18`	`19`	`{`
	`20`	`+#if WINDOWS`
`19`	`21`	`public record WindowsGpuInfo(string Description, string DriverVersion);`
`20`		`- public record WindowsMonitorInfo(string Name, string Position, string Resolution);`
	`22`	`+ public record WindowsMonitorInfo(string Name, Point Position, string Resolution);`
`21`	`23`	`public record WindowsGraphicsInfo(List<WindowsGpuInfo> Gpus, List<WindowsMonitorInfo> Monitors);`
`22`		`-`
	`24`	`+#endif`
`23`	`25`	`public record LinuxGpuInfo(string Description, string Vendor, string DriverVersion);`
`24`		`- public record LinuxMonitorInfo(string Name, string Resolution, string Coordinates);`
	`26`	`+ public record LinuxMonitorInfo(string Name, string Resolution, Point Coordinates);`
`25`	`27`	`public record LinuxGraphicsInfo(List<LinuxGpuInfo>? Gpus, List<LinuxMonitorInfo> Monitors);`
`26`	`28`
`27`	`29`	`public record MacOSGraphicsInfo(string GpuChipset, string GpuDriverVersion, string MonitorResolution);`
`28`	`30`	`public record GenericGpuInfo(string Description, string DriverVersion, string? Vendor = null);`
`29`		`- public record GenericMonitorInfo(string Name, string Resolution, string? Position = null)`
	`31`	`+ public record GenericMonitorInfo(string Name, string Resolution, Point? Position = null)`
`30`	`32`	`{`
`31`	`33`	`public override string ToString() =>`
`32`	`34`	`Position is not null`
`33`	`35`	`? $"{Name} [{Resolution} @ {Position}]"`
`34`	`36`	`: $"{Name} [{Resolution}]";`
`35`	`37`	`}`
`36`	`38`	`public record GenericGraphicsInfo(List<GenericGpuInfo>? Gpus, List<GenericMonitorInfo>? Monitors, string OperatingSystemName, string? ErrorMessage = null);`
`37`		`-`
	`39`	`+#if WINDOWS`
`38`	`40`	`private static readonly Dictionary<string, string> BuildToFriendlyName = new()`
`39`	`41`	`{`
`40`	`42`	`// Windows 11`
`@@ -61,6 +63,7 @@ public record GenericGraphicsInfo(List<GenericGpuInfo>? Gpus, List<GenericMonito`
`61`	`63`	`{ "19044", "21H2" },`
`62`	`64`	`{ "19045", "22H2" }`
`63`	`65`	`};`
	`66`	`+#endif`
`64`	`67`	`public static string GetFancyOSNameAndVersion()`
`65`	`68`	`{`
`66`	`69`	`if (OperatingSystem.IsWindows()) return GetWindowsVersion();`
`@@ -218,7 +221,7 @@ private static string GetProcessorNameLinux()`
`218`	`221`	`foreach (var line in lines)`
`219`	`222`	`{`
`220`	`223`	`if (!line.StartsWith("model name")) continue;`
`221`		`- var processorName = line[(line.IndexOf(":") + 2)..].Trim();`
	`224`	`+ var processorName = line[(line.IndexOf(':') + 2)..].Trim();`
`222`	`225`	`return processorName;`
`223`	`226`	`}`
`224`	`227`	`}`
`@@ -294,10 +297,10 @@ public static (long totalMemory, long usedMemory) GetMemoryInfo()`
`294`	`297`
`295`	`298`	`return (0, 0);`
`296`	`299`	`}`
	`300`	`+#if WINDOWS`
`297`	`301`	`[SupportedOSPlatform("windows5.1.2600")]`
`298`	`302`	`private static (long totalMemory, long usedMemory) GetMemoryInfoWindows()`
`299`	`303`	`{`
`300`		`-#if WINDOWS`
`301`	`304`	`try`
`302`	`305`	`{`
`303`	`306`	`var status = new MEMORYSTATUSEX`
`@@ -320,13 +323,11 @@ private static (long totalMemory, long usedMemory) GetMemoryInfoWindows()`
`320`	`323`	`{`
`321`	`324`	`DebugHelper.WriteException("Error reading memory info on Windows: " + ex.Message);`
`322`	`325`	`}`
`323`		`-#endif`
`324`	`326`	`return (0, 0);`
`325`	`327`	`}`
`326`	`328`	`[SupportedOSPlatform("windows5.1.2600")]`
`327`	`329`	`private static long GetAvailableMemoryWindows()`
`328`	`330`	`{`
`329`		`-#if WINDOWS`
`330`	`331`	`var status = new MEMORYSTATUSEX`
`331`	`332`	`{`
`332`	`333`	`dwLength = (uint)Marshal.SizeOf(typeof(MEMORYSTATUSEX))`
`@@ -337,9 +338,9 @@ private static long GetAvailableMemoryWindows()`
`337`	`338`	`return (long)status.ullAvailPhys;`
`338`	`339`	`}`
`339`	`340`	`DebugHelper.WriteException(new Exception("Unable to retrieve memory information."));`
`340`		`-#endif`
`341`	`341`	`return -1;`
`342`	`342`	`}`
	`343`	`+#endif`
`343`	`344`	`[SupportedOSPlatform("linux")]`
`344`	`345`	`private static (long totalMemory, long usedMemory) GetMemoryInfoLinux()`
`345`	`346`	`{`
`@@ -501,13 +502,17 @@ public static GenericGraphicsInfo GetGenericGraphicsInfo()`
`501`	`502`	`{`
`502`	`503`	`if (OperatingSystem.IsWindows())`
`503`	`504`	`{`
	`505`	`+#if WINDOWS`
`504`	`506`	`var windowsInfo = GetGraphicsInfoWindows();`
`505`	`507`	`if (windowsInfo == null)`
`506`	`508`	`return new GenericGraphicsInfo([], [], "Windows",`
`507`	`509`	`"Error retrieving Windows graphics info.");`
`508`	`510`	`var genericGpus = windowsInfo.Gpus.Select(g => new GenericGpuInfo(g.Description, g.DriverVersion)).ToList();`
`509`	`511`	`var genericMonitors = windowsInfo.Monitors.Select(m => new GenericMonitorInfo(m.Name, m.Resolution, m.Position)).ToList();`
`510`	`512`	`return new GenericGraphicsInfo(genericGpus, genericMonitors, "Windows");`
	`513`	`+#else`
	`514`	`+ return new GenericGraphicsInfo([], [], "Windows", "Compilation error for Windows specific code not being included??");`
	`515`	`+#endif`
`511`	`516`	`}`
`512`	`517`	`else`
`513`	`518`	`{`
`@@ -546,10 +551,10 @@ public static GenericGraphicsInfo GetGenericGraphicsInfo()`
`546`	`551`	`return new GenericGraphicsInfo(genericGpusmacOS, genericMonitors, "macOS");`
`547`	`552`	`}`
`548`	`553`	`}`
	`554`	`+#if WINDOWS`
`549`	`555`	`[SupportedOSPlatform("windows")]`
`550`	`556`	`public static WindowsGraphicsInfo? GetGraphicsInfoWindows()`
`551`	`557`	`{`
`552`		`-#if WINDOWS`
`553`	`558`	`try`
`554`	`559`	`{`
`555`	`560`	`const string gpuCommand = """`
`@@ -610,22 +615,63 @@ public static GenericGraphicsInfo GetGenericGraphicsInfo()`
`610`	`615`	`{`
`611`	`616`	`return null;`
`612`	`617`	`}`
`613`		`-#else`
`614`		`- return null;`
`615`		`-#endif`
`616`	`618`	`}`
`617`	`619`	`private static List<WindowsGpuInfo> ParseWindowsGpuInfo(string rawOutput)`
`618`	`620`	`{`
`619`	`621`	`var lines = rawOutput.Trim().Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries);`
`620`	`622`	`var regex = WindowsGPUInfoRegex();`
`621`	`623`	`return (from line in lines select line.Trim() into trimmedLine select regex.Match(trimmedLine) into match where match.Success let name = match.Groups[1].Value.Trim() let driver = match.Groups[2].Value.Trim() select new WindowsGpuInfo(name, driver)).ToList();`
`622`	`624`	`}`
`623`		`-`
`624`	`625`	`private static List<WindowsMonitorInfo> ParseWindowsMonitorInfo(string rawOutput)`
`625`	`626`	`{`
`626`	`627`	`var lines = rawOutput.Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries);`
`627`		`- return (from line in lines where line.StartsWith("Monitor:") select line["Monitor: ".Length..].Split([", Position: ", ", Resolution: "], StringSplitOptions.RemoveEmptyEntries) into parts where parts.Length == 3 let name = parts[0] let positionPart = parts[1] let resolutionPart = parts[2] select new WindowsMonitorInfo(name, positionPart, resolutionPart)).ToList();`
	`628`	`+ return (from line in lines where line.StartsWith("Monitor:") select line["Monitor: ".Length..].Split([", Position: ", ", Resolution: "], StringSplitOptions.RemoveEmptyEntries) into parts where parts.Length == 3 let name = parts[0] let positionPart = parts[1] let resolutionPart = parts[2] select new WindowsMonitorInfo(name, ParsePosition(positionPart), resolutionPart)).ToList();`
	`629`	`+ }`
	`630`	`+ public static Point ParsePosition(string position)`
	`631`	`+ {`
	`632`	`+ if (string.IsNullOrWhiteSpace(position))`
	`633`	`+ return new Point(0, 0);`
	`634`	`+`
	`635`	`+ try`
	`636`	`+ {`
	`637`	`+ // Remove surrounding parentheses if present`
	`638`	`+ position = position.Trim();`
	`639`	`+ if (position.StartsWith("(") && position.EndsWith(")"))`
	`640`	`+ {`
	`641`	`+ position = position.Substring(1, position.Length - 2).Trim();`
	`642`	`+ }`
	`643`	`+`
	`644`	`+ // Expected format after trimming: "X: 0, Y: 0"`
	`645`	`+ var parts = position.Split(',');`
	`646`	`+ int x = 0, y = 0;`
	`647`	`+`
	`648`	`+ foreach (var part in parts)`
	`649`	`+ {`
	`650`	`+ var kv = part.Split(':');`
	`651`	`+ if (kv.Length != 2) continue;`
	`652`	`+`
	`653`	`+ var key = kv[0].Trim().ToUpperInvariant();`
	`654`	`+ var value = int.Parse(kv[1].Trim());`
	`655`	`+`
	`656`	`+ switch (key)`
	`657`	`+ {`
	`658`	`+ case "X":`
	`659`	`+ x = value;`
	`660`	`+ break;`
	`661`	`+ case "Y":`
	`662`	`+ y = value;`
	`663`	`+ break;`
	`664`	`+ }`
	`665`	`+ }`
	`666`	`+`
	`667`	`+ return new Point(x, y);`
	`668`	`+ }`
	`669`	`+ catch`
	`670`	`+ {`
	`671`	`+ return new Point(0, 0); // fallback if parsing fails`
	`672`	`+ }`
`628`	`673`	`}`
	`674`	`+#endif`
`629`	`675`	`public static LinuxGraphicsInfo? GetGraphicsInfoLinux()`
`630`	`676`	`{`
`631`	`677`	`try`
`@@ -658,9 +704,9 @@ private static List<WindowsMonitorInfo> ParseWindowsMonitorInfo(string rawOutput`
`658`	`704`	`var glxLines = glxInfo.Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries);`
`659`	`705`	`if (string.IsNullOrWhiteSpace(driverVersion))`
`660`	`706`	`{`
`661`		`- driverVersion = glxLines.FirstOrDefault(line => line.Contains("OpenGL version"))?.Split(':')[1]?.Trim();`
	`707`	`+ driverVersion = glxLines.FirstOrDefault(glxLine => glxLine.Contains("OpenGL version"))?.Split(':')[1]?.Trim();`
`662`	`708`	`var mesaRegex = MesaRegex();`
`663`		`- var versionLine = glxLines.FirstOrDefault(line => line.Contains("OpenGL version"));`
	`709`	`+ var versionLine = glxLines.FirstOrDefault(glxLine => glxLine.Contains("OpenGL version"));`
`664`	`710`	`var mesaMatch = mesaRegex.Match(versionLine ?? string.Empty);`
`665`	`711`	`if (mesaMatch.Success)`
`666`	`712`	`driverVersion = mesaMatch.Value;`
`@@ -669,6 +715,10 @@ private static List<WindowsMonitorInfo> ParseWindowsMonitorInfo(string rawOutput`
`669`	`715`	`{`
`670`	`716`	`driverVersion = $"Kernel {kernelVersion} {driverVersion}";`
`671`	`717`	`}`
	`718`	`+ else if (driverVersion?.Contains("NVIDIA", StringComparison.InvariantCultureIgnoreCase) ?? false)`
	`719`	`+ {`
	`720`	`+ driverVersion = driverVersion?.Split(' ').Last();`
	`721`	`+ }`
`672`	`722`	`}`
`673`	`723`	`var vendor = glxLines.FirstOrDefault(line => line.Contains("OpenGL vendor string"))?.Split(':')[1]?.Trim();`
`674`	`724`	`gpuInfoList.Add(new LinuxGpuInfo(gpu, vendor, driverVersion));`
`@@ -700,11 +750,10 @@ private static List<WindowsMonitorInfo> ParseWindowsMonitorInfo(string rawOutput`
`700`	`750`	`}`
`701`	`751`
`702`	`752`	`var coordinateParts = resolutionAndCoords.Split('+');`
`703`		`- var x = coordinateParts.Length > 1 ? coordinateParts[1] : string.Empty;`
`704`		`- var y = coordinateParts.Length > 2 ? coordinateParts[2] : string.Empty;`
`705`		`- var coordinates = $"({x}, {y})";`
	`753`	`+ var x = int.Parse(coordinateParts.Length > 1 ? coordinateParts[1] : string.Empty);`
	`754`	`+ var y = int.Parse(coordinateParts.Length > 2 ? coordinateParts[2] : string.Empty);`
`706`	`755`
`707`		`- monitors.Add(new LinuxMonitorInfo(monitorName, resolution, coordinates));`
	`756`	`+ monitors.Add(new LinuxMonitorInfo(monitorName, resolution, new Point(x, y)));`
`708`	`757`	`}`
`709`	`758`	`}`
`710`	`759`	`catch (Exception ex)`
`@@ -779,7 +828,6 @@ public static bool IsHdrSupported()`
`779`	`828`	`// If they're on Linux, they should know they're using things like HDR.`
`780`	`829`	`}`
`781`	`830`
`782`		`- [SupportedOSPlatform("linux")]`
`783`	`831`	`public static bool IsWSL()`
`784`	`832`	`{`
`785`	`833`	`if (!OperatingSystem.IsLinux()) return false;`
`@@ -793,18 +841,15 @@ public static bool IsWSL()`
`793`	`841`	`return false;`
`794`	`842`	`}`
`795`	`843`	`}`
	`844`	`+#if WINDOWS`
`796`	`845`	`[SupportedOSPlatform("windows5.0")]`
`797`	`846`	`private static bool CheckWindowsHdr()`
`798`	`847`	`{`
`799`		`-#if WINDOWS`
`800`	`848`	`var hdc = PInvoke.GetDC(new HWND(IntPtr.Zero));`
`801`	`849`	`var bpp = PInvoke.GetDeviceCaps(hdc, GET_DEVICE_CAPS_INDEX.BITSPIXEL);`
`802`	`850`	`return bpp >= 30;`
`803`		`-#else`
`804`		`- return false;`
`805`		`-#endif`
`806`	`851`	`}`
`807`		`-`
	`852`	`+#endif`
`808`	`853`	`private static bool CheckMacOSHdr()`
`809`	`854`	`{`
`810`	`855`	`var displayInfo = GetMacOSDisplayInfo();`