525 lines
16 KiB
C#
525 lines
16 KiB
C#
// Licensed to the .NET Foundation under one or more agreements.
|
|
// The .NET Foundation licenses this file to you under the MIT license.
|
|
|
|
using System.Runtime.InteropServices;
|
|
using System.Text.RegularExpressions;
|
|
|
|
namespace Microsoft.Maui.Platform.Linux.Services;
|
|
|
|
/// <summary>
|
|
/// Provides HiDPI and display scaling detection for Linux.
|
|
/// </summary>
|
|
public class HiDpiService
|
|
{
|
|
private const float DefaultDpi = 96f;
|
|
private float _scaleFactor = 1.0f;
|
|
private float _dpi = DefaultDpi;
|
|
private bool _initialized;
|
|
|
|
/// <summary>
|
|
/// Gets the current scale factor.
|
|
/// </summary>
|
|
public float ScaleFactor => _scaleFactor;
|
|
|
|
/// <summary>
|
|
/// Gets the current DPI.
|
|
/// </summary>
|
|
public float Dpi => _dpi;
|
|
|
|
/// <summary>
|
|
/// Event raised when scale factor changes.
|
|
/// </summary>
|
|
public event EventHandler<ScaleChangedEventArgs>? ScaleChanged;
|
|
|
|
/// <summary>
|
|
/// Initializes the HiDPI detection service.
|
|
/// </summary>
|
|
public void Initialize()
|
|
{
|
|
if (_initialized) return;
|
|
_initialized = true;
|
|
|
|
DetectScaleFactor();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Detects the current scale factor using multiple methods.
|
|
/// </summary>
|
|
public void DetectScaleFactor()
|
|
{
|
|
float scale = 1.0f;
|
|
float dpi = DefaultDpi;
|
|
|
|
// Try multiple detection methods in order of preference
|
|
if (TryGetEnvironmentScale(out float envScale))
|
|
{
|
|
scale = envScale;
|
|
}
|
|
else if (TryGetGnomeScale(out float gnomeScale, out float gnomeDpi))
|
|
{
|
|
scale = gnomeScale;
|
|
dpi = gnomeDpi;
|
|
}
|
|
else if (TryGetKdeScale(out float kdeScale))
|
|
{
|
|
scale = kdeScale;
|
|
}
|
|
else if (TryGetX11Scale(out float x11Scale, out float x11Dpi))
|
|
{
|
|
scale = x11Scale;
|
|
dpi = x11Dpi;
|
|
}
|
|
else if (TryGetXrandrScale(out float xrandrScale))
|
|
{
|
|
scale = xrandrScale;
|
|
}
|
|
|
|
UpdateScale(scale, dpi);
|
|
}
|
|
|
|
private void UpdateScale(float scale, float dpi)
|
|
{
|
|
if (Math.Abs(_scaleFactor - scale) > 0.01f || Math.Abs(_dpi - dpi) > 0.01f)
|
|
{
|
|
var oldScale = _scaleFactor;
|
|
_scaleFactor = scale;
|
|
_dpi = dpi;
|
|
ScaleChanged?.Invoke(this, new ScaleChangedEventArgs(oldScale, scale, dpi));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets scale from environment variables.
|
|
/// </summary>
|
|
private static bool TryGetEnvironmentScale(out float scale)
|
|
{
|
|
scale = 1.0f;
|
|
|
|
// GDK_SCALE (GTK3/4)
|
|
var gdkScale = Environment.GetEnvironmentVariable("GDK_SCALE");
|
|
if (!string.IsNullOrEmpty(gdkScale) && float.TryParse(gdkScale, out float gdk))
|
|
{
|
|
scale = gdk;
|
|
return true;
|
|
}
|
|
|
|
// GDK_DPI_SCALE (GTK3/4)
|
|
var gdkDpiScale = Environment.GetEnvironmentVariable("GDK_DPI_SCALE");
|
|
if (!string.IsNullOrEmpty(gdkDpiScale) && float.TryParse(gdkDpiScale, out float gdkDpi))
|
|
{
|
|
scale = gdkDpi;
|
|
return true;
|
|
}
|
|
|
|
// QT_SCALE_FACTOR
|
|
var qtScale = Environment.GetEnvironmentVariable("QT_SCALE_FACTOR");
|
|
if (!string.IsNullOrEmpty(qtScale) && float.TryParse(qtScale, out float qt))
|
|
{
|
|
scale = qt;
|
|
return true;
|
|
}
|
|
|
|
// QT_SCREEN_SCALE_FACTORS (can be per-screen)
|
|
var qtScreenScales = Environment.GetEnvironmentVariable("QT_SCREEN_SCALE_FACTORS");
|
|
if (!string.IsNullOrEmpty(qtScreenScales))
|
|
{
|
|
// Format: "screen1=1.5;screen2=2.0" or just "1.5"
|
|
var first = qtScreenScales.Split(';')[0];
|
|
if (first.Contains('='))
|
|
{
|
|
first = first.Split('=')[1];
|
|
}
|
|
if (float.TryParse(first, out float qtScreen))
|
|
{
|
|
scale = qtScreen;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets scale from GNOME settings.
|
|
/// </summary>
|
|
private static bool TryGetGnomeScale(out float scale, out float dpi)
|
|
{
|
|
scale = 1.0f;
|
|
dpi = DefaultDpi;
|
|
|
|
try
|
|
{
|
|
// Try gsettings for GNOME
|
|
var result = RunCommand("gsettings", "get org.gnome.desktop.interface scaling-factor");
|
|
if (!string.IsNullOrEmpty(result))
|
|
{
|
|
var match = Regex.Match(result, @"uint32\s+(\d+)");
|
|
if (match.Success && int.TryParse(match.Groups[1].Value, out int gnomeScale))
|
|
{
|
|
if (gnomeScale > 0)
|
|
{
|
|
scale = gnomeScale;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Also check text-scaling-factor for fractional scaling
|
|
result = RunCommand("gsettings", "get org.gnome.desktop.interface text-scaling-factor");
|
|
if (!string.IsNullOrEmpty(result) && float.TryParse(result.Trim(), out float textScale))
|
|
{
|
|
if (textScale > 0.5f)
|
|
{
|
|
scale = Math.Max(scale, textScale);
|
|
}
|
|
}
|
|
|
|
// Check for GNOME 40+ experimental fractional scaling
|
|
result = RunCommand("gsettings", "get org.gnome.mutter experimental-features");
|
|
if (result != null && result.Contains("scale-monitor-framebuffer"))
|
|
{
|
|
// Fractional scaling is enabled, try to get actual scale
|
|
result = RunCommand("gdbus", "call --session --dest org.gnome.Mutter.DisplayConfig --object-path /org/gnome/Mutter/DisplayConfig --method org.gnome.Mutter.DisplayConfig.GetCurrentState");
|
|
if (result != null)
|
|
{
|
|
// Parse for scale value
|
|
var scaleMatch = Regex.Match(result, @"'scale':\s*<(\d+\.?\d*)>");
|
|
if (scaleMatch.Success && float.TryParse(scaleMatch.Groups[1].Value, out float mutterScale))
|
|
{
|
|
scale = mutterScale;
|
|
}
|
|
}
|
|
}
|
|
|
|
return scale > 1.0f || Math.Abs(scale - 1.0f) < 0.01f;
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets scale from KDE settings.
|
|
/// </summary>
|
|
private static bool TryGetKdeScale(out float scale)
|
|
{
|
|
scale = 1.0f;
|
|
|
|
try
|
|
{
|
|
// Try kreadconfig5 for KDE Plasma 5
|
|
var result = RunCommand("kreadconfig5", "--file kdeglobals --group KScreen --key ScaleFactor");
|
|
if (!string.IsNullOrEmpty(result) && float.TryParse(result.Trim(), out float kdeScale))
|
|
{
|
|
if (kdeScale > 0)
|
|
{
|
|
scale = kdeScale;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Try KDE Plasma 6
|
|
result = RunCommand("kreadconfig6", "--file kdeglobals --group KScreen --key ScaleFactor");
|
|
if (!string.IsNullOrEmpty(result) && float.TryParse(result.Trim(), out float kde6Scale))
|
|
{
|
|
if (kde6Scale > 0)
|
|
{
|
|
scale = kde6Scale;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Check kdeglobals config file directly
|
|
var configPath = Path.Combine(
|
|
Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
|
|
".config", "kdeglobals");
|
|
|
|
if (File.Exists(configPath))
|
|
{
|
|
var lines = File.ReadAllLines(configPath);
|
|
bool inKScreenSection = false;
|
|
foreach (var line in lines)
|
|
{
|
|
if (line.Trim() == "[KScreen]")
|
|
{
|
|
inKScreenSection = true;
|
|
continue;
|
|
}
|
|
if (inKScreenSection && line.StartsWith("["))
|
|
{
|
|
break;
|
|
}
|
|
if (inKScreenSection && line.StartsWith("ScaleFactor="))
|
|
{
|
|
var value = line.Substring("ScaleFactor=".Length);
|
|
if (float.TryParse(value, out float fileScale))
|
|
{
|
|
scale = fileScale;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets scale from X11 Xresources.
|
|
/// </summary>
|
|
private bool TryGetX11Scale(out float scale, out float dpi)
|
|
{
|
|
scale = 1.0f;
|
|
dpi = DefaultDpi;
|
|
|
|
try
|
|
{
|
|
// Try xrdb query
|
|
var result = RunCommand("xrdb", "-query");
|
|
if (!string.IsNullOrEmpty(result))
|
|
{
|
|
// Look for Xft.dpi
|
|
var match = Regex.Match(result, @"Xft\.dpi:\s*(\d+)");
|
|
if (match.Success && float.TryParse(match.Groups[1].Value, out float xftDpi))
|
|
{
|
|
dpi = xftDpi;
|
|
scale = xftDpi / DefaultDpi;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Try reading .Xresources directly
|
|
var xresourcesPath = Path.Combine(
|
|
Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
|
|
".Xresources");
|
|
|
|
if (File.Exists(xresourcesPath))
|
|
{
|
|
var content = File.ReadAllText(xresourcesPath);
|
|
var match = Regex.Match(content, @"Xft\.dpi:\s*(\d+)");
|
|
if (match.Success && float.TryParse(match.Groups[1].Value, out float fileDpi))
|
|
{
|
|
dpi = fileDpi;
|
|
scale = fileDpi / DefaultDpi;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Try X11 directly
|
|
return TryGetX11DpiDirect(out scale, out dpi);
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets DPI directly from X11 server.
|
|
/// </summary>
|
|
private bool TryGetX11DpiDirect(out float scale, out float dpi)
|
|
{
|
|
scale = 1.0f;
|
|
dpi = DefaultDpi;
|
|
|
|
try
|
|
{
|
|
var display = XOpenDisplay(IntPtr.Zero);
|
|
if (display == IntPtr.Zero) return false;
|
|
|
|
try
|
|
{
|
|
int screen = XDefaultScreen(display);
|
|
|
|
// Get physical dimensions
|
|
int widthMm = XDisplayWidthMM(display, screen);
|
|
int heightMm = XDisplayHeightMM(display, screen);
|
|
int widthPx = XDisplayWidth(display, screen);
|
|
int heightPx = XDisplayHeight(display, screen);
|
|
|
|
if (widthMm > 0 && heightMm > 0)
|
|
{
|
|
float dpiX = widthPx * 25.4f / widthMm;
|
|
float dpiY = heightPx * 25.4f / heightMm;
|
|
dpi = (dpiX + dpiY) / 2;
|
|
scale = dpi / DefaultDpi;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
finally
|
|
{
|
|
XCloseDisplay(display);
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets scale from xrandr output.
|
|
/// </summary>
|
|
private static bool TryGetXrandrScale(out float scale)
|
|
{
|
|
scale = 1.0f;
|
|
|
|
try
|
|
{
|
|
var result = RunCommand("xrandr", "--query");
|
|
if (string.IsNullOrEmpty(result)) return false;
|
|
|
|
// Look for connected displays with scaling
|
|
// Format: "eDP-1 connected primary 2560x1440+0+0 (normal left inverted right x axis y axis) 309mm x 174mm"
|
|
var lines = result.Split('\n');
|
|
foreach (var line in lines)
|
|
{
|
|
if (!line.Contains("connected") || line.Contains("disconnected")) continue;
|
|
|
|
// Try to find resolution and physical size
|
|
var resMatch = Regex.Match(line, @"(\d+)x(\d+)\+\d+\+\d+");
|
|
var mmMatch = Regex.Match(line, @"(\d+)mm x (\d+)mm");
|
|
|
|
if (resMatch.Success && mmMatch.Success)
|
|
{
|
|
if (int.TryParse(resMatch.Groups[1].Value, out int widthPx) &&
|
|
int.TryParse(mmMatch.Groups[1].Value, out int widthMm) &&
|
|
widthMm > 0)
|
|
{
|
|
float dpi = widthPx * 25.4f / widthMm;
|
|
scale = dpi / DefaultDpi;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private static string? RunCommand(string command, string arguments)
|
|
{
|
|
try
|
|
{
|
|
using var process = new System.Diagnostics.Process();
|
|
process.StartInfo = new System.Diagnostics.ProcessStartInfo
|
|
{
|
|
FileName = command,
|
|
Arguments = arguments,
|
|
RedirectStandardOutput = true,
|
|
RedirectStandardError = true,
|
|
UseShellExecute = false,
|
|
CreateNoWindow = true
|
|
};
|
|
|
|
process.Start();
|
|
var output = process.StandardOutput.ReadToEnd();
|
|
process.WaitForExit(1000);
|
|
return output;
|
|
}
|
|
catch
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Converts logical pixels to physical pixels.
|
|
/// </summary>
|
|
public float ToPhysicalPixels(float logicalPixels)
|
|
{
|
|
return logicalPixels * _scaleFactor;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Converts physical pixels to logical pixels.
|
|
/// </summary>
|
|
public float ToLogicalPixels(float physicalPixels)
|
|
{
|
|
return physicalPixels / _scaleFactor;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the recommended font scale factor.
|
|
/// </summary>
|
|
public float GetFontScaleFactor()
|
|
{
|
|
// Some desktop environments use a separate text scaling factor
|
|
try
|
|
{
|
|
var result = RunCommand("gsettings", "get org.gnome.desktop.interface text-scaling-factor");
|
|
if (!string.IsNullOrEmpty(result) && float.TryParse(result.Trim(), out float textScale))
|
|
{
|
|
return textScale;
|
|
}
|
|
}
|
|
catch { }
|
|
|
|
return _scaleFactor;
|
|
}
|
|
|
|
#region X11 Interop
|
|
|
|
[DllImport("libX11.so.6")]
|
|
private static extern nint XOpenDisplay(nint display);
|
|
|
|
[DllImport("libX11.so.6")]
|
|
private static extern void XCloseDisplay(nint display);
|
|
|
|
[DllImport("libX11.so.6")]
|
|
private static extern int XDefaultScreen(nint display);
|
|
|
|
[DllImport("libX11.so.6")]
|
|
private static extern int XDisplayWidth(nint display, int screen);
|
|
|
|
[DllImport("libX11.so.6")]
|
|
private static extern int XDisplayHeight(nint display, int screen);
|
|
|
|
[DllImport("libX11.so.6")]
|
|
private static extern int XDisplayWidthMM(nint display, int screen);
|
|
|
|
[DllImport("libX11.so.6")]
|
|
private static extern int XDisplayHeightMM(nint display, int screen);
|
|
|
|
#endregion
|
|
}
|
|
|
|
/// <summary>
|
|
/// Event args for scale change events.
|
|
/// </summary>
|
|
public class ScaleChangedEventArgs : EventArgs
|
|
{
|
|
/// <summary>
|
|
/// Gets the old scale factor.
|
|
/// </summary>
|
|
public float OldScale { get; }
|
|
|
|
/// <summary>
|
|
/// Gets the new scale factor.
|
|
/// </summary>
|
|
public float NewScale { get; }
|
|
|
|
/// <summary>
|
|
/// Gets the new DPI.
|
|
/// </summary>
|
|
public float NewDpi { get; }
|
|
|
|
public ScaleChangedEventArgs(float oldScale, float newScale, float newDpi)
|
|
{
|
|
OldScale = oldScale;
|
|
NewScale = newScale;
|
|
NewDpi = newDpi;
|
|
}
|
|
}
|