open-maui/OpenMaui
2
0
Fork 0
Code Issues Releases 1

Implement architecture improvements for 1.0 release

Browse Source 
Priority 1 - Stability:
- Dirty region invalidation in SkiaRenderingEngine
- Font fallback chain (FontFallbackManager) for emoji/CJK/international text
- Input method polish with Fcitx5 support alongside IBus

Priority 2 - Platform Integration:
- Portal file picker (PortalFilePickerService) with zenity/kdialog fallback
- System theme detection (SystemThemeService) for GNOME/KDE/XFCE/etc
- Notification actions support with D-Bus callbacks

Priority 3 - Performance:
- GPU acceleration (GpuRenderingEngine) with OpenGL, software fallback
- Virtualization manager (VirtualizationManager) for list recycling

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
This commit is contained in:
David H. Friedel Jr.
2025-12-28 09:53:40 -05:00
parent b18d5a11f3
commit 10222090fd
10 changed files with 3274 additions and 13 deletions
Download Patch File Download Diff File Expand all files Collapse all files

326
Services/Fcitx5InputMethodService.cs Normal file
View File

@@ -0,0 +1,326 @@
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Diagnostics;
using System.Text;
namespace Microsoft.Maui.Platform.Linux.Services;
/// <summary>
/// Fcitx5 Input Method service using D-Bus interface.
/// Provides IME support for systems using Fcitx5 (common on some distros).
/// </summary>
public class Fcitx5InputMethodService : IInputMethodService, IDisposable
{
private IInputContext? _currentContext;
private string _preEditText = string.Empty;
private int _preEditCursorPosition;
private bool _isActive;
private bool _disposed;
private Process? _dBusMonitor;
private string? _inputContextPath;
public bool IsActive => _isActive;
public string PreEditText => _preEditText;
public int PreEditCursorPosition => _preEditCursorPosition;
public event EventHandler<TextCommittedEventArgs>? TextCommitted;
public event EventHandler<PreEditChangedEventArgs>? PreEditChanged;
public event EventHandler? PreEditEnded;
public void Initialize(nint windowHandle)
{
try
{
// Create input context via D-Bus
var output = RunDBusCommand(
"call --session " +
"--dest org.fcitx.Fcitx5 " +
"--object-path /org/freedesktop/portal/inputmethod " +
"--method org.fcitx.Fcitx.InputMethod1.CreateInputContext " +
"\"maui-linux\" \"\"");
if (!string.IsNullOrEmpty(output) && output.Contains("/"))
{
// Parse the object path from output like: (objectpath '/org/fcitx/...',)
var start = output.IndexOf("'/");
var end = output.IndexOf("'", start + 1);
if (start >= 0 && end > start)
{
_inputContextPath = output.Substring(start + 1, end - start - 1);
Console.WriteLine($"Fcitx5InputMethodService: Created context at {_inputContextPath}");
StartMonitoring();
}
}
else
{
Console.WriteLine("Fcitx5InputMethodService: Failed to create input context");
}
}
catch (Exception ex)
{
Console.WriteLine($"Fcitx5InputMethodService: Initialization failed - {ex.Message}");
}
}
private void StartMonitoring()
{
if (string.IsNullOrEmpty(_inputContextPath)) return;
Task.Run(async () =>
{
try
{
var startInfo = new ProcessStartInfo
{
FileName = "dbus-monitor",
Arguments = $"--session \"path='{_inputContextPath}'\"",
UseShellExecute = false,
RedirectStandardOutput = true,
CreateNoWindow = true
};
_dBusMonitor = Process.Start(startInfo);
if (_dBusMonitor == null) return;
var reader = _dBusMonitor.StandardOutput;
while (!_disposed && !_dBusMonitor.HasExited)
{
var line = await reader.ReadLineAsync();
if (line == null) break;
// Parse signals for commit and preedit
if (line.Contains("CommitString"))
{
await ProcessCommitSignal(reader);
}
else if (line.Contains("UpdatePreedit"))
{
await ProcessPreeditSignal(reader);
}
}
}
catch (Exception ex)
{
Console.WriteLine($"Fcitx5InputMethodService: Monitor error - {ex.Message}");
}
});
}
private async Task ProcessCommitSignal(StreamReader reader)
{
try
{
for (int i = 0; i < 5; i++)
{
var line = await reader.ReadLineAsync();
if (line == null) break;
if (line.Contains("string"))
{
var match = System.Text.RegularExpressions.Regex.Match(line, @"string\s+""([^""]*)""");
if (match.Success)
{
var text = match.Groups[1].Value;
_preEditText = string.Empty;
_preEditCursorPosition = 0;
_isActive = false;
TextCommitted?.Invoke(this, new TextCommittedEventArgs(text));
_currentContext?.OnTextCommitted(text);
break;
}
}
}
}
catch { }
}
private async Task ProcessPreeditSignal(StreamReader reader)
{
try
{
for (int i = 0; i < 10; i++)
{
var line = await reader.ReadLineAsync();
if (line == null) break;
if (line.Contains("string"))
{
var match = System.Text.RegularExpressions.Regex.Match(line, @"string\s+""([^""]*)""");
if (match.Success)
{
_preEditText = match.Groups[1].Value;
_isActive = !string.IsNullOrEmpty(_preEditText);
PreEditChanged?.Invoke(this, new PreEditChangedEventArgs(_preEditText, _preEditCursorPosition, new List<PreEditAttribute>()));
_currentContext?.OnPreEditChanged(_preEditText, _preEditCursorPosition);
break;
}
}
}
}
catch { }
}
public void SetFocus(IInputContext? context)
{
_currentContext = context;
if (!string.IsNullOrEmpty(_inputContextPath))
{
if (context != null)
{
RunDBusCommand(
$"call --session --dest org.fcitx.Fcitx5 " +
$"--object-path {_inputContextPath} " +
$"--method org.fcitx.Fcitx.InputContext1.FocusIn");
}
else
{
RunDBusCommand(
$"call --session --dest org.fcitx.Fcitx5 " +
$"--object-path {_inputContextPath} " +
$"--method org.fcitx.Fcitx.InputContext1.FocusOut");
}
}
}
public void SetCursorLocation(int x, int y, int width, int height)
{
if (string.IsNullOrEmpty(_inputContextPath)) return;
RunDBusCommand(
$"call --session --dest org.fcitx.Fcitx5 " +
$"--object-path {_inputContextPath} " +
$"--method org.fcitx.Fcitx.InputContext1.SetCursorRect " +
$"{x} {y} {width} {height}");
}
public bool ProcessKeyEvent(uint keyCode, KeyModifiers modifiers, bool isKeyDown)
{
if (string.IsNullOrEmpty(_inputContextPath)) return false;
uint state = ConvertModifiers(modifiers);
if (!isKeyDown) state |= 0x40000000; // Release flag
var result = RunDBusCommand(
$"call --session --dest org.fcitx.Fcitx5 " +
$"--object-path {_inputContextPath} " +
$"--method org.fcitx.Fcitx.InputContext1.ProcessKeyEvent " +
$"{keyCode} {keyCode} {state} {(isKeyDown ? "true" : "false")} 0");
return result?.Contains("true") == true;
}
private uint ConvertModifiers(KeyModifiers modifiers)
{
uint state = 0;
if (modifiers.HasFlag(KeyModifiers.Shift)) state |= 1;
if (modifiers.HasFlag(KeyModifiers.CapsLock)) state |= 2;
if (modifiers.HasFlag(KeyModifiers.Control)) state |= 4;
if (modifiers.HasFlag(KeyModifiers.Alt)) state |= 8;
if (modifiers.HasFlag(KeyModifiers.Super)) state |= 64;
return state;
}
public void Reset()
{
if (!string.IsNullOrEmpty(_inputContextPath))
{
RunDBusCommand(
$"call --session --dest org.fcitx.Fcitx5 " +
$"--object-path {_inputContextPath} " +
$"--method org.fcitx.Fcitx.InputContext1.Reset");
}
_preEditText = string.Empty;
_preEditCursorPosition = 0;
_isActive = false;
PreEditEnded?.Invoke(this, EventArgs.Empty);
_currentContext?.OnPreEditEnded();
}
public void Shutdown()
{
Dispose();
}
private string? RunDBusCommand(string args)
{
try
{
var startInfo = new ProcessStartInfo
{
FileName = "gdbus",
Arguments = args,
UseShellExecute = false,
RedirectStandardOutput = true,
RedirectStandardError = true,
CreateNoWindow = true
};
using var process = Process.Start(startInfo);
if (process == null) return null;
var output = process.StandardOutput.ReadToEnd();
process.WaitForExit(1000);
return output;
}
catch
{
return null;
}
}
public void Dispose()
{
if (_disposed) return;
_disposed = true;
try
{
_dBusMonitor?.Kill();
_dBusMonitor?.Dispose();
}
catch { }
if (!string.IsNullOrEmpty(_inputContextPath))
{
RunDBusCommand(
$"call --session --dest org.fcitx.Fcitx5 " +
$"--object-path {_inputContextPath} " +
$"--method org.fcitx.Fcitx.InputContext1.Destroy");
}
}
/// <summary>
/// Checks if Fcitx5 is available on the system.
/// </summary>
public static bool IsAvailable()
{
try
{
var startInfo = new ProcessStartInfo
{
FileName = "gdbus",
Arguments = "introspect --session --dest org.fcitx.Fcitx5 --object-path /org/freedesktop/portal/inputmethod",
UseShellExecute = false,
RedirectStandardOutput = true,
RedirectStandardError = true,
CreateNoWindow = true
};
using var process = Process.Start(startInfo);
if (process == null) return false;
process.WaitForExit(1000);
return process.ExitCode == 0;
}
catch
{
return false;
}
}
}

310
Services/FontFallbackManager.cs Normal file
View File

@@ -0,0 +1,310 @@
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using SkiaSharp;
namespace Microsoft.Maui.Platform.Linux.Services;
/// <summary>
/// Manages font fallback for text rendering when the primary font
/// doesn't contain glyphs for certain characters (emoji, CJK, etc.).
/// </summary>
public class FontFallbackManager
{
private static FontFallbackManager? _instance;
private static readonly object _lock = new();
/// <summary>
/// Gets the singleton instance of the font fallback manager.
/// </summary>
public static FontFallbackManager Instance
{
get
{
if (_instance == null)
{
lock (_lock)
{
_instance ??= new FontFallbackManager();
}
}
return _instance;
}
}
// Fallback font chain ordered by priority
private readonly string[] _fallbackFonts = new[]
{
// Primary sans-serif fonts
"Noto Sans",
"DejaVu Sans",
"Liberation Sans",
"FreeSans",
// Emoji fonts
"Noto Color Emoji",
"Noto Emoji",
"Symbola",
"Segoe UI Emoji",
// CJK fonts (Chinese, Japanese, Korean)
"Noto Sans CJK SC",
"Noto Sans CJK TC",
"Noto Sans CJK JP",
"Noto Sans CJK KR",
"WenQuanYi Micro Hei",
"WenQuanYi Zen Hei",
"Droid Sans Fallback",
// Arabic and RTL scripts
"Noto Sans Arabic",
"Noto Naskh Arabic",
"DejaVu Sans",
// Indic scripts
"Noto Sans Devanagari",
"Noto Sans Tamil",
"Noto Sans Bengali",
"Noto Sans Telugu",
// Thai
"Noto Sans Thai",
"Loma",
// Hebrew
"Noto Sans Hebrew",
// System fallbacks
"Sans",
"sans-serif"
};
// Cache for typeface lookups
private readonly Dictionary<string, SKTypeface?> _typefaceCache = new();
private readonly Dictionary<(int codepoint, string preferredFont), SKTypeface?> _glyphCache = new();
private FontFallbackManager()
{
// Pre-cache common fallback fonts
foreach (var fontName in _fallbackFonts.Take(10))
{
GetCachedTypeface(fontName);
}
}
/// <summary>
/// Gets a typeface that can render the specified codepoint.
/// Falls back through the font chain if the preferred font doesn't support it.
/// </summary>
/// <param name="codepoint">The Unicode codepoint to render.</param>
/// <param name="preferred">The preferred typeface to use.</param>
/// <returns>A typeface that can render the codepoint, or the preferred typeface as fallback.</returns>
public SKTypeface GetTypefaceForCodepoint(int codepoint, SKTypeface preferred)
{
// Check cache first
var cacheKey = (codepoint, preferred.FamilyName);
if (_glyphCache.TryGetValue(cacheKey, out var cached))
{
return cached ?? preferred;
}
// Check if preferred font has the glyph
if (TypefaceContainsGlyph(preferred, codepoint))
{
_glyphCache[cacheKey] = preferred;
return preferred;
}
// Search fallback fonts
foreach (var fontName in _fallbackFonts)
{
var fallback = GetCachedTypeface(fontName);
if (fallback != null && TypefaceContainsGlyph(fallback, codepoint))
{
_glyphCache[cacheKey] = fallback;
return fallback;
}
}
// No fallback found, return preferred (will show tofu)
_glyphCache[cacheKey] = null;
return preferred;
}
/// <summary>
/// Gets a typeface that can render all codepoints in the text.
/// For mixed scripts, use ShapeTextWithFallback instead.
/// </summary>
public SKTypeface GetTypefaceForText(string text, SKTypeface preferred)
{
if (string.IsNullOrEmpty(text))
return preferred;
// Check first non-ASCII character
foreach (var rune in text.EnumerateRunes())
{
if (rune.Value > 127)
{
return GetTypefaceForCodepoint(rune.Value, preferred);
}
}
return preferred;
}
/// <summary>
/// Shapes text with automatic font fallback for mixed scripts.
/// Returns a list of text runs, each with its own typeface.
/// </summary>
public List<TextRun> ShapeTextWithFallback(string text, SKTypeface preferred)
{
var runs = new List<TextRun>();
if (string.IsNullOrEmpty(text))
return runs;
var currentRun = new StringBuilder();
SKTypeface? currentTypeface = null;
int runStart = 0;
int charIndex = 0;
foreach (var rune in text.EnumerateRunes())
{
var typeface = GetTypefaceForCodepoint(rune.Value, preferred);
if (currentTypeface == null)
{
currentTypeface = typeface;
}
else if (typeface.FamilyName != currentTypeface.FamilyName)
{
// Typeface changed - save current run
if (currentRun.Length > 0)
{
runs.Add(new TextRun(currentRun.ToString(), currentTypeface, runStart));
}
currentRun.Clear();
currentTypeface = typeface;
runStart = charIndex;
}
currentRun.Append(rune.ToString());
charIndex += rune.Utf16SequenceLength;
}
// Add final run
if (currentRun.Length > 0 && currentTypeface != null)
{
runs.Add(new TextRun(currentRun.ToString(), currentTypeface, runStart));
}
return runs;
}
/// <summary>
/// Checks if a typeface is available on the system.
/// </summary>
public bool IsFontAvailable(string fontFamily)
{
var typeface = GetCachedTypeface(fontFamily);
return typeface != null && typeface.FamilyName.Equals(fontFamily, StringComparison.OrdinalIgnoreCase);
}
/// <summary>
/// Gets a list of available fallback fonts on this system.
/// </summary>
public IEnumerable<string> GetAvailableFallbackFonts()
{
foreach (var fontName in _fallbackFonts)
{
if (IsFontAvailable(fontName))
{
yield return fontName;
}
}
}
private SKTypeface? GetCachedTypeface(string fontFamily)
{
if (_typefaceCache.TryGetValue(fontFamily, out var cached))
{
return cached;
}
var typeface = SKTypeface.FromFamilyName(fontFamily);
// Check if we actually got the requested font or a substitution
if (typeface != null && !typeface.FamilyName.Equals(fontFamily, StringComparison.OrdinalIgnoreCase))
{
// Got a substitution, don't cache it as the requested font
typeface = null;
}
_typefaceCache[fontFamily] = typeface;
return typeface;
}
private bool TypefaceContainsGlyph(SKTypeface typeface, int codepoint)
{
// Use SKFont to check glyph coverage
using var font = new SKFont(typeface, 12);
var glyphs = new ushort[1];
var chars = char.ConvertFromUtf32(codepoint);
font.GetGlyphs(chars, glyphs);
// Glyph ID 0 is the "missing glyph" (tofu)
return glyphs[0] != 0;
}
}
/// <summary>
/// Represents a run of text with a specific typeface.
/// </summary>
public class TextRun
{
/// <summary>
/// The text content of this run.
/// </summary>
public string Text { get; }
/// <summary>
/// The typeface to use for this run.
/// </summary>
public SKTypeface Typeface { get; }
/// <summary>
/// The starting character index in the original string.
/// </summary>
public int StartIndex { get; }
public TextRun(string text, SKTypeface typeface, int startIndex)
{
Text = text;
Typeface = typeface;
StartIndex = startIndex;
}
}
/// <summary>
/// StringBuilder for internal use.
/// </summary>
file class StringBuilder
{
private readonly List<char> _chars = new();
public int Length => _chars.Count;
public void Append(string s)
{
_chars.AddRange(s);
}
public void Clear()
{
_chars.Clear();
}
public override string ToString()
{
return new string(_chars.ToArray());
}
}

33
Services/InputMethodServiceFactory.cs
View File

@@ -45,6 +45,7 @@ public static class InputMethodServiceFactory
return imePreference.ToLowerInvariant() switch
{
"ibus" => CreateIBusService(),
"fcitx" or "fcitx5" => CreateFcitx5Service(),
"xim" => CreateXIMService(),
"none" => new NullInputMethodService(),
_ => CreateAutoService()
@@ -56,13 +57,30 @@ public static class InputMethodServiceFactory
private static IInputMethodService CreateAutoService()
{
// Try IBus first (most common on modern Linux)
// Check GTK_IM_MODULE for hint
var imModule = Environment.GetEnvironmentVariable("GTK_IM_MODULE")?.ToLowerInvariant();
// Try Fcitx5 first if it's the configured IM
if (imModule?.Contains("fcitx") == true && Fcitx5InputMethodService.IsAvailable())
{
Console.WriteLine("InputMethodServiceFactory: Using Fcitx5");
return CreateFcitx5Service();
}
// Try IBus (most common on modern Linux)
if (IsIBusAvailable())
{
Console.WriteLine("InputMethodServiceFactory: Using IBus");
return CreateIBusService();
}
// Try Fcitx5 as fallback
if (Fcitx5InputMethodService.IsAvailable())
{
Console.WriteLine("InputMethodServiceFactory: Using Fcitx5");
return CreateFcitx5Service();
}
// Fall back to XIM
if (IsXIMAvailable())
{
@@ -88,6 +106,19 @@ public static class InputMethodServiceFactory
}
}
private static IInputMethodService CreateFcitx5Service()
{
try
{
return new Fcitx5InputMethodService();
}
catch (Exception ex)
{
Console.WriteLine($"InputMethodServiceFactory: Failed to create Fcitx5 service - {ex.Message}");
return new NullInputMethodService();
}
}
private static IInputMethodService CreateXIMService()
{
try

328
Services/NotificationService.cs
View File

@@ -2,16 +2,33 @@
// The .NET Foundation licenses this file to you under the MIT license.
using System.Diagnostics;
using System.Text;
using System.Collections.Concurrent;
namespace Microsoft.Maui.Platform.Linux.Services;
/// <summary>
/// Linux notification service using notify-send (libnotify).
/// Linux notification service using notify-send (libnotify) or D-Bus directly.
/// Supports interactive notifications with action callbacks.
/// </summary>
public class NotificationService
{
private readonly string _appName;
private readonly string? _defaultIconPath;
private readonly ConcurrentDictionary<uint, NotificationContext> _activeNotifications = new();
private static uint _notificationIdCounter = 1;
private Process? _dBusMonitor;
private bool _monitoringActions;
/// <summary>
/// Event raised when a notification action is invoked.
/// </summary>
public event EventHandler<NotificationActionEventArgs>? ActionInvoked;
/// <summary>
/// Event raised when a notification is closed.
/// </summary>
public event EventHandler<NotificationClosedEventArgs>? NotificationClosed;
public NotificationService(string appName = "MAUI Application", string? defaultIconPath = null)
{
@@ -19,6 +36,165 @@ public class NotificationService
_defaultIconPath = defaultIconPath;
}
/// <summary>
/// Starts monitoring for notification action callbacks via D-Bus.
/// Call this once at application startup if you want to receive action callbacks.
/// </summary>
public void StartActionMonitoring()
{
if (_monitoringActions) return;
_monitoringActions = true;
// Start D-Bus monitor for notification signals
Task.Run(MonitorNotificationSignals);
}
/// <summary>
/// Stops monitoring for notification action callbacks.
/// </summary>
public void StopActionMonitoring()
{
_monitoringActions = false;
try
{
_dBusMonitor?.Kill();
_dBusMonitor?.Dispose();
_dBusMonitor = null;
}
catch { }
}
private async Task MonitorNotificationSignals()
{
try
{
var startInfo = new ProcessStartInfo
{
FileName = "dbus-monitor",
Arguments = "--session \"interface='org.freedesktop.Notifications'\"",
UseShellExecute = false,
RedirectStandardOutput = true,
RedirectStandardError = true,
CreateNoWindow = true
};
_dBusMonitor = Process.Start(startInfo);
if (_dBusMonitor == null) return;
var reader = _dBusMonitor.StandardOutput;
var buffer = new StringBuilder();
while (_monitoringActions && !_dBusMonitor.HasExited)
{
var line = await reader.ReadLineAsync();
if (line == null) break;
buffer.AppendLine(line);
// Look for ActionInvoked or NotificationClosed signals
if (line.Contains("ActionInvoked"))
{
await ProcessActionInvoked(reader);
}
else if (line.Contains("NotificationClosed"))
{
await ProcessNotificationClosed(reader);
}
}
}
catch (Exception ex)
{
Console.WriteLine($"[NotificationService] D-Bus monitor error: {ex.Message}");
}
}
private async Task ProcessActionInvoked(StreamReader reader)
{
try
{
// Read the signal data (notification id and action key)
uint notificationId = 0;
string? actionKey = null;
for (int i = 0; i < 10; i++) // Read a few lines to get the data
{
var line = await reader.ReadLineAsync();
if (line == null) break;
if (line.Contains("uint32"))
{
var idMatch = System.Text.RegularExpressions.Regex.Match(line, @"uint32\s+(\d+)");
if (idMatch.Success)
{
notificationId = uint.Parse(idMatch.Groups[1].Value);
}
}
else if (line.Contains("string"))
{
var strMatch = System.Text.RegularExpressions.Regex.Match(line, @"string\s+""([^""]*)""");
if (strMatch.Success && actionKey == null)
{
actionKey = strMatch.Groups[1].Value;
}
}
if (notificationId > 0 && actionKey != null) break;
}
if (notificationId > 0 && actionKey != null)
{
if (_activeNotifications.TryGetValue(notificationId, out var context))
{
// Invoke callback if registered
if (context.ActionCallbacks?.TryGetValue(actionKey, out var callback) == true)
{
callback?.Invoke();
}
ActionInvoked?.Invoke(this, new NotificationActionEventArgs(notificationId, actionKey, context.Tag));
}
}
}
catch { }
}
private async Task ProcessNotificationClosed(StreamReader reader)
{
try
{
uint notificationId = 0;
uint reason = 0;
for (int i = 0; i < 5; i++)
{
var line = await reader.ReadLineAsync();
if (line == null) break;
if (line.Contains("uint32"))
{
var match = System.Text.RegularExpressions.Regex.Match(line, @"uint32\s+(\d+)");
if (match.Success)
{
if (notificationId == 0)
notificationId = uint.Parse(match.Groups[1].Value);
else
reason = uint.Parse(match.Groups[1].Value);
}
}
}
if (notificationId > 0)
{
_activeNotifications.TryRemove(notificationId, out var context);
NotificationClosed?.Invoke(this, new NotificationClosedEventArgs(
notificationId,
(NotificationCloseReason)reason,
context?.Tag));
}
}
catch { }
}
/// <summary>
/// Shows a simple notification.
/// </summary>
@@ -31,6 +207,72 @@ public class NotificationService
});
}
/// <summary>
/// Shows a notification with action buttons and callbacks.
/// </summary>
/// <param name="title">Notification title.</param>
/// <param name="message">Notification message.</param>
/// <param name="actions">List of action buttons with callbacks.</param>
/// <param name="tag">Optional tag to identify the notification in events.</param>
/// <returns>The notification ID.</returns>
public async Task<uint> ShowWithActionsAsync(
string title,
string message,
IEnumerable<NotificationAction> actions,
string? tag = null)
{
var notificationId = _notificationIdCounter++;
// Store context for callbacks
var context = new NotificationContext
{
Tag = tag,
ActionCallbacks = actions.ToDictionary(a => a.Key, a => a.Callback)
};
_activeNotifications[notificationId] = context;
// Build actions dictionary for options
var actionDict = actions.ToDictionary(a => a.Key, a => a.Label);
await ShowAsync(new NotificationOptions
{
Title = title,
Message = message,
Actions = actionDict
});
return notificationId;
}
/// <summary>
/// Cancels/closes an active notification.
/// </summary>
public async Task CancelAsync(uint notificationId)
{
try
{
// Use gdbus to close the notification
var startInfo = new ProcessStartInfo
{
FileName = "gdbus",
Arguments = $"call --session --dest org.freedesktop.Notifications " +
$"--object-path /org/freedesktop/Notifications " +
$"--method org.freedesktop.Notifications.CloseNotification {notificationId}",
UseShellExecute = false,
CreateNoWindow = true
};
using var process = Process.Start(startInfo);
if (process != null)
{
await process.WaitForExitAsync();
}
_activeNotifications.TryRemove(notificationId, out _);
}
catch { }
}
/// <summary>
/// Shows a notification with options.
/// </summary>
@@ -209,3 +451,87 @@ public enum NotificationUrgency
Normal,
Critical
}
/// <summary>
/// Reason a notification was closed.
/// </summary>
public enum NotificationCloseReason
{
Expired = 1,
Dismissed = 2,
Closed = 3,
Undefined = 4
}
/// <summary>
/// Internal context for tracking active notifications.
/// </summary>
internal class NotificationContext
{
public string? Tag { get; set; }
public Dictionary<string, Action?>? ActionCallbacks { get; set; }
}
/// <summary>
/// Event args for notification action events.
/// </summary>
public class NotificationActionEventArgs : EventArgs
{
public uint NotificationId { get; }
public string ActionKey { get; }
public string? Tag { get; }
public NotificationActionEventArgs(uint notificationId, string actionKey, string? tag)
{
NotificationId = notificationId;
ActionKey = actionKey;
Tag = tag;
}
}
/// <summary>
/// Event args for notification closed events.
/// </summary>
public class NotificationClosedEventArgs : EventArgs
{
public uint NotificationId { get; }
public NotificationCloseReason Reason { get; }
public string? Tag { get; }
public NotificationClosedEventArgs(uint notificationId, NotificationCloseReason reason, string? tag)
{
NotificationId = notificationId;
Reason = reason;
Tag = tag;
}
}
/// <summary>
/// Defines an action button for a notification.
/// </summary>
public class NotificationAction
{
/// <summary>
/// Internal action key (not displayed).
/// </summary>
public string Key { get; set; } = "";
/// <summary>
/// Display label for the action button.
/// </summary>
public string Label { get; set; } = "";
/// <summary>
/// Callback to invoke when the action is clicked.
/// </summary>
public Action? Callback { get; set; }
public NotificationAction() { }
public NotificationAction(string key, string label, Action? callback = null)
{
Key = key;
Label = label;
Callback = callback;
}
}

479
Services/PortalFilePickerService.cs Normal file
View File

@@ -0,0 +1,479 @@
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using Microsoft.Maui.Storage;
using System.Diagnostics;
using System.Text;
namespace Microsoft.Maui.Platform.Linux.Services;
/// <summary>
/// File picker service using xdg-desktop-portal for native dialogs.
/// Falls back to zenity/kdialog if portal is unavailable.
/// </summary>
public class PortalFilePickerService : IFilePicker
{
private bool _portalAvailable = true;
private string? _fallbackTool;
public PortalFilePickerService()
{
DetectAvailableTools();
}
private void DetectAvailableTools()
{
// Check if portal is available
_portalAvailable = CheckPortalAvailable();
if (!_portalAvailable)
{
// Check for fallback tools
if (IsCommandAvailable("zenity"))
_fallbackTool = "zenity";
else if (IsCommandAvailable("kdialog"))
_fallbackTool = "kdialog";
else if (IsCommandAvailable("yad"))
_fallbackTool = "yad";
}
}
private bool CheckPortalAvailable()
{
try
{
// Check if xdg-desktop-portal is running
var output = RunCommand("busctl", "--user list | grep -q org.freedesktop.portal.Desktop && echo yes");
return output.Trim() == "yes";
}
catch
{
return false;
}
}
private bool IsCommandAvailable(string command)
{
try
{
var output = RunCommand("which", command);
return !string.IsNullOrWhiteSpace(output);
}
catch
{
return false;
}
}
public async Task<FileResult?> PickAsync(PickOptions? options = null)
{
options ??= new PickOptions();
var results = await PickFilesAsync(options, allowMultiple: false);
return results.FirstOrDefault();
}
public async Task<IEnumerable<FileResult>> PickMultipleAsync(PickOptions? options = null)
{
options ??= new PickOptions();
return await PickFilesAsync(options, allowMultiple: true);
}
private async Task<IEnumerable<FileResult>> PickFilesAsync(PickOptions options, bool allowMultiple)
{
if (_portalAvailable)
{
return await PickWithPortalAsync(options, allowMultiple);
}
else if (_fallbackTool != null)
{
return await PickWithFallbackAsync(options, allowMultiple);
}
else
{
// No file picker available
Console.WriteLine("[FilePickerService] No file picker available (install xdg-desktop-portal, zenity, or kdialog)");
return Enumerable.Empty<FileResult>();
}
}
private async Task<IEnumerable<FileResult>> PickWithPortalAsync(PickOptions options, bool allowMultiple)
{
try
{
// Use gdbus to call the portal
var filterArgs = BuildPortalFilterArgs(options.FileTypes);
var multipleArg = allowMultiple ? "true" : "false";
var title = options.PickerTitle ?? "Open File";
// Build the D-Bus call
var args = new StringBuilder();
args.Append("call --session ");
args.Append("--dest org.freedesktop.portal.Desktop ");
args.Append("--object-path /org/freedesktop/portal/desktop ");
args.Append("--method org.freedesktop.portal.FileChooser.OpenFile ");
args.Append("\"\" "); // Parent window (empty for no parent)
args.Append($"\"{EscapeForShell(title)}\" "); // Title
// Options dictionary
args.Append("@a{sv} {");
args.Append($"'multiple': <{multipleArg}>");
if (filterArgs != null)
{
args.Append($", 'filters': <{filterArgs}>");
}
args.Append("}");
var output = await Task.Run(() => RunCommand("gdbus", args.ToString()));
// Parse the response to get the request path
// Response format: (objectpath '/org/freedesktop/portal/desktop/request/...',)
var requestPath = ParseRequestPath(output);
if (string.IsNullOrEmpty(requestPath))
{
return Enumerable.Empty<FileResult>();
}
// Wait for the response signal (simplified - in production use D-Bus signal subscription)
await Task.Delay(100);
// For now, fall back to synchronous zenity if portal response parsing is complex
if (_fallbackTool != null)
{
return await PickWithFallbackAsync(options, allowMultiple);
}
return Enumerable.Empty<FileResult>();
}
catch (Exception ex)
{
Console.WriteLine($"[FilePickerService] Portal error: {ex.Message}");
// Fall back to zenity/kdialog
if (_fallbackTool != null)
{
return await PickWithFallbackAsync(options, allowMultiple);
}
return Enumerable.Empty<FileResult>();
}
}
private async Task<IEnumerable<FileResult>> PickWithFallbackAsync(PickOptions options, bool allowMultiple)
{
return _fallbackTool switch
{
"zenity" => await PickWithZenityAsync(options, allowMultiple),
"kdialog" => await PickWithKdialogAsync(options, allowMultiple),
"yad" => await PickWithYadAsync(options, allowMultiple),
_ => Enumerable.Empty<FileResult>()
};
}
private async Task<IEnumerable<FileResult>> PickWithZenityAsync(PickOptions options, bool allowMultiple)
{
var args = new StringBuilder();
args.Append("--file-selection ");
if (!string.IsNullOrEmpty(options.PickerTitle))
{
args.Append($"--title=\"{EscapeForShell(options.PickerTitle)}\" ");
}
if (allowMultiple)
{
args.Append("--multiple --separator=\"|\" ");
}
// Add file filters from FilePickerFileType
var extensions = GetExtensionsFromFileType(options.FileTypes);
if (extensions.Count > 0)
{
var filterPattern = string.Join(" ", extensions.Select(e => $"*{e}"));
args.Append($"--file-filter=\"Files | {filterPattern}\" ");
}
var output = await Task.Run(() => RunCommand("zenity", args.ToString()));
if (string.IsNullOrWhiteSpace(output))
{
return Enumerable.Empty<FileResult>();
}
var files = output.Trim().Split('|', StringSplitOptions.RemoveEmptyEntries);
return files.Select(f => new FileResult(f.Trim())).ToList();
}
private async Task<IEnumerable<FileResult>> PickWithKdialogAsync(PickOptions options, bool allowMultiple)
{
var args = new StringBuilder();
args.Append("--getopenfilename ");
// Start directory
args.Append(". ");
// Add file filters
var extensions = GetExtensionsFromFileType(options.FileTypes);
if (extensions.Count > 0)
{
var filterPattern = string.Join(" ", extensions.Select(e => $"*{e}"));
args.Append($"\"Files ({filterPattern})\" ");
}
if (!string.IsNullOrEmpty(options.PickerTitle))
{
args.Append($"--title \"{EscapeForShell(options.PickerTitle)}\" ");
}
if (allowMultiple)
{
args.Append("--multiple --separate-output ");
}
var output = await Task.Run(() => RunCommand("kdialog", args.ToString()));
if (string.IsNullOrWhiteSpace(output))
{
return Enumerable.Empty<FileResult>();
}
var files = output.Trim().Split('\n', StringSplitOptions.RemoveEmptyEntries);
return files.Select(f => new FileResult(f.Trim())).ToList();
}
private async Task<IEnumerable<FileResult>> PickWithYadAsync(PickOptions options, bool allowMultiple)
{
// YAD is similar to zenity
var args = new StringBuilder();
args.Append("--file ");
if (!string.IsNullOrEmpty(options.PickerTitle))
{
args.Append($"--title=\"{EscapeForShell(options.PickerTitle)}\" ");
}
if (allowMultiple)
{
args.Append("--multiple --separator=\"|\" ");
}
var extensions = GetExtensionsFromFileType(options.FileTypes);
if (extensions.Count > 0)
{
var filterPattern = string.Join(" ", extensions.Select(e => $"*{e}"));
args.Append($"--file-filter=\"Files | {filterPattern}\" ");
}
var output = await Task.Run(() => RunCommand("yad", args.ToString()));
if (string.IsNullOrWhiteSpace(output))
{
return Enumerable.Empty<FileResult>();
}
var files = output.Trim().Split('|', StringSplitOptions.RemoveEmptyEntries);
return files.Select(f => new FileResult(f.Trim())).ToList();
}
/// <summary>
/// Extracts file extensions from a MAUI FilePickerFileType.
/// </summary>
private List<string> GetExtensionsFromFileType(FilePickerFileType? fileType)
{
var extensions = new List<string>();
if (fileType == null) return extensions;
try
{
// FilePickerFileType.Value is IEnumerable<string> for the current platform
var value = fileType.Value;
if (value == null) return extensions;
foreach (var ext in value)
{
// Skip MIME types, only take file extensions
if (ext.StartsWith(".") || (!ext.Contains('/') && !ext.Contains('*')))
{
var normalized = ext.StartsWith(".") ? ext : $".{ext}";
if (!extensions.Contains(normalized))
{
extensions.Add(normalized);
}
}
}
}
catch
{
// Silently fail if we can't parse the file type
}
return extensions;
}
private string? BuildPortalFilterArgs(FilePickerFileType? fileType)
{
var extensions = GetExtensionsFromFileType(fileType);
if (extensions.Count == 0)
return null;
var patterns = string.Join(", ", extensions.Select(e => $"(uint32 0, '*{e}')"));
return $"[('Files', [{patterns}])]";
}
private string? ParseRequestPath(string output)
{
// Parse D-Bus response like: (objectpath '/org/freedesktop/portal/desktop/request/...',)
var start = output.IndexOf("'/");
var end = output.IndexOf("',", start);
if (start >= 0 && end > start)
{
return output.Substring(start + 1, end - start - 1);
}
return null;
}
private string EscapeForShell(string input)
{
return input.Replace("\"", "\\\"").Replace("'", "\\'");
}
private string RunCommand(string command, string arguments)
{
try
{
using var process = new Process
{
StartInfo = new ProcessStartInfo
{
FileName = command,
Arguments = arguments,
RedirectStandardOutput = true,
RedirectStandardError = true,
UseShellExecute = false,
CreateNoWindow = true
}
};
process.Start();
var output = process.StandardOutput.ReadToEnd();
process.WaitForExit(30000);
return output;
}
catch (Exception ex)
{
Console.WriteLine($"[FilePickerService] Command error: {ex.Message}");
return "";
}
}
}
/// <summary>
/// Folder picker service using xdg-desktop-portal for native dialogs.
/// </summary>
public class PortalFolderPickerService
{
public async Task<FolderPickerResult> PickAsync(FolderPickerOptions? options = null, CancellationToken cancellationToken = default)
{
options ??= new FolderPickerOptions();
// Use zenity/kdialog for folder selection (simpler than portal)
string? selectedFolder = null;
if (IsCommandAvailable("zenity"))
{
var args = $"--file-selection --directory --title=\"{options.Title ?? "Select Folder"}\"";
selectedFolder = await Task.Run(() => RunCommand("zenity", args)?.Trim());
}
else if (IsCommandAvailable("kdialog"))
{
var args = $"--getexistingdirectory . --title \"{options.Title ?? "Select Folder"}\"";
selectedFolder = await Task.Run(() => RunCommand("kdialog", args)?.Trim());
}
if (!string.IsNullOrEmpty(selectedFolder) && Directory.Exists(selectedFolder))
{
return new FolderPickerResult(new FolderResult(selectedFolder));
}
return new FolderPickerResult(null);
}
public async Task<FolderPickerResult> PickAsync(CancellationToken cancellationToken = default)
{
return await PickAsync(null, cancellationToken);
}
private bool IsCommandAvailable(string command)
{
try
{
var output = RunCommand("which", command);
return !string.IsNullOrWhiteSpace(output);
}
catch
{
return false;
}
}
private string? RunCommand(string command, string arguments)
{
try
{
using var process = new Process
{
StartInfo = new ProcessStartInfo
{
FileName = command,
Arguments = arguments,
RedirectStandardOutput = true,
UseShellExecute = false,
CreateNoWindow = true
}
};
process.Start();
var output = process.StandardOutput.ReadToEnd();
process.WaitForExit(30000);
return output;
}
catch
{
return null;
}
}
}
/// <summary>
/// Result of a folder picker operation.
/// </summary>
public class FolderResult
{
public string Path { get; }
public string Name => System.IO.Path.GetFileName(Path) ?? Path;
public FolderResult(string path)
{
Path = path;
}
}
/// <summary>
/// Result wrapper for folder picker.
/// </summary>
public class FolderPickerResult
{
public FolderResult? Folder { get; }
public bool WasSuccessful => Folder != null;
public FolderPickerResult(FolderResult? folder)
{
Folder = folder;
}
}
/// <summary>
/// Options for folder picker.
/// </summary>
public class FolderPickerOptions
{
public string? Title { get; set; }
public string? InitialDirectory { get; set; }
}

481
Services/SystemThemeService.cs Normal file
View File

@@ -0,0 +1,481 @@
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using SkiaSharp;
using System.Diagnostics;
namespace Microsoft.Maui.Platform.Linux.Services;
/// <summary>
/// Detects and monitors system theme settings (dark/light mode, accent colors).
/// Supports GNOME, KDE, and GTK-based environments.
/// </summary>
public class SystemThemeService
{
private static SystemThemeService? _instance;
private static readonly object _lock = new();
/// <summary>
/// Gets the singleton instance of the system theme service.
/// </summary>
public static SystemThemeService Instance
{
get
{
if (_instance == null)
{
lock (_lock)
{
_instance ??= new SystemThemeService();
}
}
return _instance;
}
}
/// <summary>
/// The current system theme.
/// </summary>
public SystemTheme CurrentTheme { get; private set; } = SystemTheme.Light;
/// <summary>
/// The system accent color (if available).
/// </summary>
public SKColor AccentColor { get; private set; } = new SKColor(0x21, 0x96, 0xF3); // Default blue
/// <summary>
/// The detected desktop environment.
/// </summary>
public DesktopEnvironment Desktop { get; private set; } = DesktopEnvironment.Unknown;
/// <summary>
/// Event raised when the theme changes.
/// </summary>
public event EventHandler<ThemeChangedEventArgs>? ThemeChanged;
/// <summary>
/// System colors based on the current theme.
/// </summary>
public SystemColors Colors { get; private set; }
private FileSystemWatcher? _settingsWatcher;
private SystemThemeService()
{
DetectDesktopEnvironment();
DetectTheme();
UpdateColors();
SetupWatcher();
}
private void DetectDesktopEnvironment()
{
var xdgDesktop = Environment.GetEnvironmentVariable("XDG_CURRENT_DESKTOP")?.ToLowerInvariant() ?? "";
var desktopSession = Environment.GetEnvironmentVariable("DESKTOP_SESSION")?.ToLowerInvariant() ?? "";
if (xdgDesktop.Contains("gnome") || desktopSession.Contains("gnome"))
{
Desktop = DesktopEnvironment.GNOME;
}
else if (xdgDesktop.Contains("kde") || xdgDesktop.Contains("plasma") || desktopSession.Contains("plasma"))
{
Desktop = DesktopEnvironment.KDE;
}
else if (xdgDesktop.Contains("xfce") || desktopSession.Contains("xfce"))
{
Desktop = DesktopEnvironment.XFCE;
}
else if (xdgDesktop.Contains("mate") || desktopSession.Contains("mate"))
{
Desktop = DesktopEnvironment.MATE;
}
else if (xdgDesktop.Contains("cinnamon") || desktopSession.Contains("cinnamon"))
{
Desktop = DesktopEnvironment.Cinnamon;
}
else if (xdgDesktop.Contains("lxqt"))
{
Desktop = DesktopEnvironment.LXQt;
}
else if (xdgDesktop.Contains("lxde"))
{
Desktop = DesktopEnvironment.LXDE;
}
else
{
Desktop = DesktopEnvironment.Unknown;
}
}
private void DetectTheme()
{
var theme = Desktop switch
{
DesktopEnvironment.GNOME => DetectGnomeTheme(),
DesktopEnvironment.KDE => DetectKdeTheme(),
DesktopEnvironment.XFCE => DetectXfceTheme(),
DesktopEnvironment.Cinnamon => DetectCinnamonTheme(),
_ => DetectGtkTheme()
};
CurrentTheme = theme ?? SystemTheme.Light;
// Try to get accent color
AccentColor = Desktop switch
{
DesktopEnvironment.GNOME => GetGnomeAccentColor(),
DesktopEnvironment.KDE => GetKdeAccentColor(),
_ => new SKColor(0x21, 0x96, 0xF3)
};
}
private SystemTheme? DetectGnomeTheme()
{
try
{
// gsettings get org.gnome.desktop.interface color-scheme
var output = RunCommand("gsettings", "get org.gnome.desktop.interface color-scheme");
if (output.Contains("prefer-dark"))
return SystemTheme.Dark;
if (output.Contains("prefer-light") || output.Contains("default"))
return SystemTheme.Light;
// Fallback: check GTK theme name
output = RunCommand("gsettings", "get org.gnome.desktop.interface gtk-theme");
if (output.ToLowerInvariant().Contains("dark"))
return SystemTheme.Dark;
}
catch { }
return null;
}
private SystemTheme? DetectKdeTheme()
{
try
{
// Read ~/.config/kdeglobals
var configPath = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
".config", "kdeglobals");
if (File.Exists(configPath))
{
var content = File.ReadAllText(configPath);
// Look for ColorScheme or LookAndFeelPackage
if (content.Contains("BreezeDark", StringComparison.OrdinalIgnoreCase) ||
content.Contains("Dark", StringComparison.OrdinalIgnoreCase))
{
return SystemTheme.Dark;
}
}
}
catch { }
return null;
}
private SystemTheme? DetectXfceTheme()
{
try
{
var output = RunCommand("xfconf-query", "-c xsettings -p /Net/ThemeName");
if (output.ToLowerInvariant().Contains("dark"))
return SystemTheme.Dark;
}
catch { }
return DetectGtkTheme();
}
private SystemTheme? DetectCinnamonTheme()
{
try
{
var output = RunCommand("gsettings", "get org.cinnamon.desktop.interface gtk-theme");
if (output.ToLowerInvariant().Contains("dark"))
return SystemTheme.Dark;
}
catch { }
return null;
}
private SystemTheme? DetectGtkTheme()
{
try
{
// Try GTK3 settings
var configPath = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
".config", "gtk-3.0", "settings.ini");
if (File.Exists(configPath))
{
var content = File.ReadAllText(configPath);
var lines = content.Split('\n');
foreach (var line in lines)
{
if (line.StartsWith("gtk-theme-name=", StringComparison.OrdinalIgnoreCase))
{
var themeName = line.Substring("gtk-theme-name=".Length).Trim();
if (themeName.Contains("dark", StringComparison.OrdinalIgnoreCase))
return SystemTheme.Dark;
}
if (line.StartsWith("gtk-application-prefer-dark-theme=", StringComparison.OrdinalIgnoreCase))
{
var value = line.Substring("gtk-application-prefer-dark-theme=".Length).Trim();
if (value == "1" || value.Equals("true", StringComparison.OrdinalIgnoreCase))
return SystemTheme.Dark;
}
}
}
}
catch { }
return null;
}
private SKColor GetGnomeAccentColor()
{
try
{
var output = RunCommand("gsettings", "get org.gnome.desktop.interface accent-color");
// Returns something like 'blue', 'teal', 'green', etc.
return output.Trim().Trim('\'') switch
{
"blue" => new SKColor(0x35, 0x84, 0xe4),
"teal" => new SKColor(0x2a, 0xc3, 0xde),
"green" => new SKColor(0x3a, 0x94, 0x4a),
"yellow" => new SKColor(0xf6, 0xd3, 0x2d),
"orange" => new SKColor(0xff, 0x78, 0x00),
"red" => new SKColor(0xe0, 0x1b, 0x24),
"pink" => new SKColor(0xd6, 0x56, 0x8c),
"purple" => new SKColor(0x91, 0x41, 0xac),
"slate" => new SKColor(0x5e, 0x5c, 0x64),
_ => new SKColor(0x21, 0x96, 0xF3)
};
}
catch
{
return new SKColor(0x21, 0x96, 0xF3);
}
}
private SKColor GetKdeAccentColor()
{
try
{
var configPath = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
".config", "kdeglobals");
if (File.Exists(configPath))
{
var content = File.ReadAllText(configPath);
var lines = content.Split('\n');
bool inColorsHeader = false;
foreach (var line in lines)
{
if (line.StartsWith("[Colors:Header]"))
{
inColorsHeader = true;
continue;
}
if (line.StartsWith("[") && inColorsHeader)
{
break;
}
if (inColorsHeader && line.StartsWith("BackgroundNormal="))
{
var rgb = line.Substring("BackgroundNormal=".Length).Split(',');
if (rgb.Length >= 3 &&
byte.TryParse(rgb[0], out var r) &&
byte.TryParse(rgb[1], out var g) &&
byte.TryParse(rgb[2], out var b))
{
return new SKColor(r, g, b);
}
}
}
}
}
catch { }
return new SKColor(0x21, 0x96, 0xF3);
}
private void UpdateColors()
{
Colors = CurrentTheme == SystemTheme.Dark
? new SystemColors
{
Background = new SKColor(0x1e, 0x1e, 0x1e),
Surface = new SKColor(0x2d, 0x2d, 0x2d),
Primary = AccentColor,
OnPrimary = SKColors.White,
Text = new SKColor(0xf0, 0xf0, 0xf0),
TextSecondary = new SKColor(0xa0, 0xa0, 0xa0),
Border = new SKColor(0x40, 0x40, 0x40),
Divider = new SKColor(0x3a, 0x3a, 0x3a),
Error = new SKColor(0xcf, 0x66, 0x79),
Success = new SKColor(0x81, 0xc9, 0x95)
}
: new SystemColors
{
Background = new SKColor(0xfa, 0xfa, 0xfa),
Surface = SKColors.White,
Primary = AccentColor,
OnPrimary = SKColors.White,
Text = new SKColor(0x21, 0x21, 0x21),
TextSecondary = new SKColor(0x75, 0x75, 0x75),
Border = new SKColor(0xe0, 0xe0, 0xe0),
Divider = new SKColor(0xee, 0xee, 0xee),
Error = new SKColor(0xb0, 0x00, 0x20),
Success = new SKColor(0x2e, 0x7d, 0x32)
};
}
private void SetupWatcher()
{
try
{
var configDir = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
".config");
if (Directory.Exists(configDir))
{
_settingsWatcher = new FileSystemWatcher(configDir)
{
NotifyFilter = NotifyFilters.LastWrite,
IncludeSubdirectories = true,
EnableRaisingEvents = true
};
_settingsWatcher.Changed += OnSettingsChanged;
}
}
catch { }
}
private void OnSettingsChanged(object sender, FileSystemEventArgs e)
{
// Debounce and check relevant files
if (e.Name?.Contains("kdeglobals") == true ||
e.Name?.Contains("gtk") == true ||
e.Name?.Contains("settings") == true)
{
// Re-detect theme after a short delay
Task.Delay(500).ContinueWith(_ =>
{
var oldTheme = CurrentTheme;
DetectTheme();
UpdateColors();
if (oldTheme != CurrentTheme)
{
ThemeChanged?.Invoke(this, new ThemeChangedEventArgs(CurrentTheme));
}
});
}
}
private string RunCommand(string command, string arguments)
{
try
{
using var process = new Process
{
StartInfo = new ProcessStartInfo
{
FileName = command,
Arguments = arguments,
RedirectStandardOutput = true,
UseShellExecute = false,
CreateNoWindow = true
}
};
process.Start();
var output = process.StandardOutput.ReadToEnd();
process.WaitForExit(1000);
return output;
}
catch
{
return "";
}
}
/// <summary>
/// Forces a theme refresh.
/// </summary>
public void RefreshTheme()
{
var oldTheme = CurrentTheme;
DetectTheme();
UpdateColors();
if (oldTheme != CurrentTheme)
{
ThemeChanged?.Invoke(this, new ThemeChangedEventArgs(CurrentTheme));
}
}
}
/// <summary>
/// System theme (light or dark mode).
/// </summary>
public enum SystemTheme
{
Light,
Dark
}
/// <summary>
/// Detected desktop environment.
/// </summary>
public enum DesktopEnvironment
{
Unknown,
GNOME,
KDE,
XFCE,
MATE,
Cinnamon,
LXQt,
LXDE
}
/// <summary>
/// Event args for theme changes.
/// </summary>
public class ThemeChangedEventArgs : EventArgs
{
public SystemTheme NewTheme { get; }
public ThemeChangedEventArgs(SystemTheme newTheme)
{
NewTheme = newTheme;
}
}
/// <summary>
/// System colors based on the current theme.
/// </summary>
public class SystemColors
{
public SKColor Background { get; init; }
public SKColor Surface { get; init; }
public SKColor Primary { get; init; }
public SKColor OnPrimary { get; init; }
public SKColor Text { get; init; }
public SKColor TextSecondary { get; init; }
public SKColor Border { get; init; }
public SKColor Divider { get; init; }
public SKColor Error { get; init; }
public SKColor Success { get; init; }
}

307
Services/VirtualizationManager.cs Normal file
View File

@@ -0,0 +1,307 @@
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using SkiaSharp;
namespace Microsoft.Maui.Platform.Linux.Services;
/// <summary>
/// Manages view recycling for virtualized lists and collections.
/// Implements a pool-based recycling strategy to minimize allocations.
/// </summary>
public class VirtualizationManager<T> where T : SkiaView
{
private readonly Dictionary<int, T> _activeViews = new();
private readonly Queue<T> _recyclePool = new();
private readonly Func<T> _viewFactory;
private readonly Action<T>? _viewRecycler;
private readonly int _maxPoolSize;
private int _firstVisibleIndex = -1;
private int _lastVisibleIndex = -1;
/// <summary>
/// Number of views currently active (bound to data).
/// </summary>
public int ActiveViewCount => _activeViews.Count;
/// <summary>
/// Number of views in the recycle pool.
/// </summary>
public int PooledViewCount => _recyclePool.Count;
/// <summary>
/// Current visible range.
/// </summary>
public (int First, int Last) VisibleRange => (_firstVisibleIndex, _lastVisibleIndex);
/// <summary>
/// Creates a new virtualization manager.
/// </summary>
/// <param name="viewFactory">Factory function to create new views.</param>
/// <param name="viewRecycler">Optional function to reset views before recycling.</param>
/// <param name="maxPoolSize">Maximum number of views to keep in the recycle pool.</param>
public VirtualizationManager(
Func<T> viewFactory,
Action<T>? viewRecycler = null,
int maxPoolSize = 20)
{
_viewFactory = viewFactory ?? throw new ArgumentNullException(nameof(viewFactory));
_viewRecycler = viewRecycler;
_maxPoolSize = maxPoolSize;
}
/// <summary>
/// Updates the visible range and recycles views that scrolled out of view.
/// </summary>
/// <param name="firstVisible">Index of first visible item.</param>
/// <param name="lastVisible">Index of last visible item.</param>
public void UpdateVisibleRange(int firstVisible, int lastVisible)
{
if (firstVisible == _firstVisibleIndex && lastVisible == _lastVisibleIndex)
return;
// Recycle views that scrolled out of view
var toRecycle = new List<int>();
foreach (var kvp in _activeViews)
{
if (kvp.Key < firstVisible || kvp.Key > lastVisible)
{
toRecycle.Add(kvp.Key);
}
}
foreach (var index in toRecycle)
{
RecycleView(index);
}
_firstVisibleIndex = firstVisible;
_lastVisibleIndex = lastVisible;
}
/// <summary>
/// Gets or creates a view for the specified index.
/// </summary>
/// <param name="index">Item index.</param>
/// <param name="bindData">Action to bind data to the view.</param>
/// <returns>A view bound to the data.</returns>
public T GetOrCreateView(int index, Action<T> bindData)
{
if (_activeViews.TryGetValue(index, out var existing))
{
return existing;
}
// Get from pool or create new
T view;
if (_recyclePool.Count > 0)
{
view = _recyclePool.Dequeue();
}
else
{
view = _viewFactory();
}
// Bind data
bindData(view);
_activeViews[index] = view;
return view;
}
/// <summary>
/// Gets an existing view for the index, or null if not active.
/// </summary>
public T? GetActiveView(int index)
{
return _activeViews.TryGetValue(index, out var view) ? view : default;
}
/// <summary>
/// Recycles a view at the specified index.
/// </summary>
private void RecycleView(int index)
{
if (!_activeViews.TryGetValue(index, out var view))
return;
_activeViews.Remove(index);
// Reset the view
_viewRecycler?.Invoke(view);
// Add to pool if not full
if (_recyclePool.Count < _maxPoolSize)
{
_recyclePool.Enqueue(view);
}
else
{
// Pool is full, dispose the view
view.Dispose();
}
}
/// <summary>
/// Clears all active views and the recycle pool.
/// </summary>
public void Clear()
{
foreach (var view in _activeViews.Values)
{
view.Dispose();
}
_activeViews.Clear();
while (_recyclePool.Count > 0)
{
_recyclePool.Dequeue().Dispose();
}
_firstVisibleIndex = -1;
_lastVisibleIndex = -1;
}
/// <summary>
/// Removes a specific item and recycles its view.
/// </summary>
public void RemoveItem(int index)
{
RecycleView(index);
// Shift indices for items after the removed one
var toShift = _activeViews
.Where(kvp => kvp.Key > index)
.OrderBy(kvp => kvp.Key)
.ToList();
foreach (var kvp in toShift)
{
_activeViews.Remove(kvp.Key);
_activeViews[kvp.Key - 1] = kvp.Value;
}
}
/// <summary>
/// Inserts an item and shifts existing indices.
/// </summary>
public void InsertItem(int index)
{
// Shift indices for items at or after the insert position
var toShift = _activeViews
.Where(kvp => kvp.Key >= index)
.OrderByDescending(kvp => kvp.Key)
.ToList();
foreach (var kvp in toShift)
{
_activeViews.Remove(kvp.Key);
_activeViews[kvp.Key + 1] = kvp.Value;
}
}
}
/// <summary>
/// Extension methods for virtualization.
/// </summary>
public static class VirtualizationExtensions
{
/// <summary>
/// Calculates visible item range for a vertical list.
/// </summary>
/// <param name="scrollOffset">Current scroll offset.</param>
/// <param name="viewportHeight">Height of visible area.</param>
/// <param name="itemHeight">Height of each item (fixed).</param>
/// <param name="itemSpacing">Spacing between items.</param>
/// <param name="totalItems">Total number of items.</param>
/// <returns>Tuple of (firstVisible, lastVisible) indices.</returns>
public static (int first, int last) CalculateVisibleRange(
float scrollOffset,
float viewportHeight,
float itemHeight,
float itemSpacing,
int totalItems)
{
if (totalItems == 0)
return (-1, -1);
var rowHeight = itemHeight + itemSpacing;
var first = Math.Max(0, (int)(scrollOffset / rowHeight));
var last = Math.Min(totalItems - 1, (int)((scrollOffset + viewportHeight) / rowHeight) + 1);
return (first, last);
}
/// <summary>
/// Calculates visible item range for variable height items.
/// </summary>
/// <param name="scrollOffset">Current scroll offset.</param>
/// <param name="viewportHeight">Height of visible area.</param>
/// <param name="getItemHeight">Function to get height of item at index.</param>
/// <param name="itemSpacing">Spacing between items.</param>
/// <param name="totalItems">Total number of items.</param>
/// <returns>Tuple of (firstVisible, lastVisible) indices.</returns>
public static (int first, int last) CalculateVisibleRangeVariable(
float scrollOffset,
float viewportHeight,
Func<int, float> getItemHeight,
float itemSpacing,
int totalItems)
{
if (totalItems == 0)
return (-1, -1);
int first = 0;
float cumulativeHeight = 0;
// Find first visible
for (int i = 0; i < totalItems; i++)
{
var itemHeight = getItemHeight(i);
if (cumulativeHeight + itemHeight > scrollOffset)
{
first = i;
break;
}
cumulativeHeight += itemHeight + itemSpacing;
}
// Find last visible
int last = first;
var endOffset = scrollOffset + viewportHeight;
for (int i = first; i < totalItems; i++)
{
var itemHeight = getItemHeight(i);
if (cumulativeHeight > endOffset)
{
break;
}
last = i;
cumulativeHeight += itemHeight + itemSpacing;
}
return (first, last);
}
/// <summary>
/// Calculates visible item range for a grid layout.
/// </summary>
public static (int firstRow, int lastRow) CalculateVisibleGridRange(
float scrollOffset,
float viewportHeight,
float rowHeight,
float rowSpacing,
int totalRows)
{
if (totalRows == 0)
return (-1, -1);
var effectiveRowHeight = rowHeight + rowSpacing;
var first = Math.Max(0, (int)(scrollOffset / effectiveRowHeight));
var last = Math.Min(totalRows - 1, (int)((scrollOffset + viewportHeight) / effectiveRowHeight) + 1);
return (first, last);
}
}