5 Commits

Author SHA1 Message Date
2a4e35cd39 Fix compilation: restore clean RC1 codebase
- Restore clean BindableProperty.Create syntax from RC1 commit
- Remove decompiler artifacts with mangled delegate types
- Add Svg.Skia package reference for icon support
- Fix duplicate type definitions
- Library now compiles successfully (0 errors)

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

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
2026-01-01 07:43:44 -05:00
33914bf572 Add fixfuckup.md - recovery plan for lost XAML and AppThemeBinding work 2026-01-01 06:30:34 -05:00
1f096c38dc Update with recovered code from VM binaries (Jan 1)
Recovered from decompiled OpenMaui.Controls.Linux.dll:
- SkiaShell.cs: FlyoutHeader, FlyoutFooter, scroll support (918 -> 1325 lines)
- X11Window.cs: Cursor support (XCreateFontCursor, XDefineCursor)
- All handlers with dark mode support
- All services with latest implementations
- LinuxApplication with theme change handling
2026-01-01 06:22:48 -05:00
1e84c6168a Add WebView support via WebKitGTK
Implements Priority 4 item: WebView via WebKitGTK

New files:
- Interop/WebKitGtk.cs - P/Invoke bindings for WebKitGTK library
- Views/LinuxWebView.cs - WebKitGTK-based WebView platform control
- Handlers/WebViewHandler.Linux.cs - MAUI handler for WebView on Linux
- samples_temp/WebViewDemo/ - Demo app for WebView functionality

Features:
- Full HTML5/CSS3/JavaScript support via WebKitGTK
- Navigation (back/forward/reload)
- URL and HTML source loading
- JavaScript evaluation
- Navigation events (Navigating/Navigated)
- Automatic GTK event processing

Requirements:
- libwebkit2gtk-4.1-0 package on target Linux system

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

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
2025-12-28 10:46:11 -05:00
Admin
10a061777e fix(ci): remove pwsh dependency from release workflow 2025-12-28 10:44:15 -05:00
32 changed files with 3566 additions and 2813 deletions

View File

@@ -21,15 +21,6 @@ jobs:
- name: Checkout
uses: actions/checkout@v4
- name: Extract version from tag
id: version
shell: pwsh
run: |
$tag = "${{ github.ref_name }}"
$version = $tag -replace '^v', ''
echo "VERSION=$version" >> $env:GITHUB_OUTPUT
echo "Building version: $version"
- name: Restore dependencies
run: C:\dotnet\dotnet.exe restore
@@ -38,9 +29,13 @@ jobs:
- name: Run tests
run: C:\dotnet\dotnet.exe test --configuration Release --no-build --verbosity normal
continue-on-error: true
- name: Pack NuGet package
run: C:\dotnet\dotnet.exe pack --configuration Release --no-build -o ./nupkg /p:PackageVersion=${{ steps.version.outputs.VERSION }}
run: C:\dotnet\dotnet.exe pack --configuration Release --no-build -o ./nupkg
- name: Publish to NuGet.org
run: C:\dotnet\dotnet.exe nuget push ./nupkg/*.nupkg --api-key ${{ secrets.NUGET_API_KEY }} --source https://api.nuget.org/v3/index.json --skip-duplicate
run: |
foreach ($pkg in (Get-ChildItem .\nupkg\*.nupkg)) {
C:\dotnet\dotnet.exe nuget push $pkg.FullName --api-key ${{ secrets.NUGET_API_KEY }} --source https://api.nuget.org/v3/index.json --skip-duplicate
}

View File

@@ -46,6 +46,9 @@
<!-- HarfBuzz for advanced text shaping -->
<PackageReference Include="HarfBuzzSharp" Version="7.3.0.3" />
<PackageReference Include="HarfBuzzSharp.NativeAssets.Linux" Version="7.3.0.3" />
<!-- SVG support for icon loading -->
<PackageReference Include="Svg.Skia" Version="2.0.0.4" />
</ItemGroup>
<!-- Include README and icon in package -->

View File

@@ -1,349 +0,0 @@
// 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 Microsoft.Maui.Platform.Linux.Window;
using System.Runtime.InteropServices;
namespace Microsoft.Maui.Platform.Linux.Rendering;
/// <summary>
/// GPU-accelerated rendering engine using OpenGL.
/// Falls back to software rendering if GPU initialization fails.
/// </summary>
public class GpuRenderingEngine : IDisposable
{
private readonly X11Window _window;
private GRContext? _grContext;
private GRBackendRenderTarget? _renderTarget;
private SKSurface? _surface;
private SKCanvas? _canvas;
private bool _disposed;
private bool _gpuAvailable;
private int _width;
private int _height;
// Fallback to software rendering
private SKBitmap? _softwareBitmap;
private SKCanvas? _softwareCanvas;
// Dirty region tracking
private readonly List<SKRect> _dirtyRegions = new();
private readonly object _dirtyLock = new();
private bool _fullRedrawNeeded = true;
private const int MaxDirtyRegions = 32;
/// <summary>
/// Gets whether GPU acceleration is available and active.
/// </summary>
public bool IsGpuAccelerated => _gpuAvailable && _grContext != null;
/// <summary>
/// Gets the current rendering backend name.
/// </summary>
public string BackendName => IsGpuAccelerated ? "OpenGL" : "Software";
public int Width => _width;
public int Height => _height;
public GpuRenderingEngine(X11Window window)
{
_window = window;
_width = window.Width;
_height = window.Height;
// Try to initialize GPU rendering
_gpuAvailable = TryInitializeGpu();
if (!_gpuAvailable)
{
Console.WriteLine("[GpuRenderingEngine] GPU not available, using software rendering");
InitializeSoftwareRendering();
}
_window.Resized += OnWindowResized;
_window.Exposed += OnWindowExposed;
}
private bool TryInitializeGpu()
{
try
{
// Check if we can create an OpenGL context
var glInterface = GRGlInterface.Create();
if (glInterface == null)
{
Console.WriteLine("[GpuRenderingEngine] Failed to create GL interface");
return false;
}
_grContext = GRContext.CreateGl(glInterface);
if (_grContext == null)
{
Console.WriteLine("[GpuRenderingEngine] Failed to create GR context");
glInterface.Dispose();
return false;
}
CreateGpuSurface();
Console.WriteLine("[GpuRenderingEngine] GPU acceleration enabled");
return true;
}
catch (Exception ex)
{
Console.WriteLine($"[GpuRenderingEngine] GPU initialization failed: {ex.Message}");
return false;
}
}
private void CreateGpuSurface()
{
if (_grContext == null) return;
_renderTarget?.Dispose();
_surface?.Dispose();
var width = Math.Max(1, _width);
var height = Math.Max(1, _height);
// Create framebuffer info (assuming default framebuffer 0)
var framebufferInfo = new GRGlFramebufferInfo(0, SKColorType.Rgba8888.ToGlSizedFormat());
_renderTarget = new GRBackendRenderTarget(
width, height,
0, // sample count
8, // stencil bits
framebufferInfo);
_surface = SKSurface.Create(
_grContext,
_renderTarget,
GRSurfaceOrigin.BottomLeft,
SKColorType.Rgba8888);
if (_surface == null)
{
Console.WriteLine("[GpuRenderingEngine] Failed to create GPU surface, falling back to software");
_gpuAvailable = false;
InitializeSoftwareRendering();
return;
}
_canvas = _surface.Canvas;
}
private void InitializeSoftwareRendering()
{
var width = Math.Max(1, _width);
var height = Math.Max(1, _height);
_softwareBitmap?.Dispose();
_softwareCanvas?.Dispose();
var imageInfo = new SKImageInfo(width, height, SKColorType.Bgra8888, SKAlphaType.Premul);
_softwareBitmap = new SKBitmap(imageInfo);
_softwareCanvas = new SKCanvas(_softwareBitmap);
_canvas = _softwareCanvas;
}
private void OnWindowResized(object? sender, (int Width, int Height) size)
{
_width = size.Width;
_height = size.Height;
if (_gpuAvailable && _grContext != null)
{
CreateGpuSurface();
}
else
{
InitializeSoftwareRendering();
}
_fullRedrawNeeded = true;
}
private void OnWindowExposed(object? sender, EventArgs e)
{
_fullRedrawNeeded = true;
}
/// <summary>
/// Marks a region as needing redraw.
/// </summary>
public void InvalidateRegion(SKRect region)
{
if (region.IsEmpty || region.Width <= 0 || region.Height <= 0)
return;
region = SKRect.Intersect(region, new SKRect(0, 0, Width, Height));
if (region.IsEmpty) return;
lock (_dirtyLock)
{
if (_dirtyRegions.Count >= MaxDirtyRegions)
{
_fullRedrawNeeded = true;
_dirtyRegions.Clear();
return;
}
_dirtyRegions.Add(region);
}
}
/// <summary>
/// Marks the entire surface as needing redraw.
/// </summary>
public void InvalidateAll()
{
_fullRedrawNeeded = true;
}
/// <summary>
/// Renders the view tree with dirty region optimization.
/// </summary>
public void Render(SkiaView rootView)
{
if (_canvas == null) return;
// Measure and arrange
var availableSize = new SKSize(Width, Height);
rootView.Measure(availableSize);
rootView.Arrange(new SKRect(0, 0, Width, Height));
// Determine regions to redraw
List<SKRect> regionsToRedraw;
bool isFullRedraw;
lock (_dirtyLock)
{
isFullRedraw = _fullRedrawNeeded || _dirtyRegions.Count == 0;
if (isFullRedraw)
{
regionsToRedraw = new List<SKRect> { new SKRect(0, 0, Width, Height) };
_dirtyRegions.Clear();
_fullRedrawNeeded = false;
}
else
{
regionsToRedraw = new List<SKRect>(_dirtyRegions);
_dirtyRegions.Clear();
}
}
// Render each dirty region
foreach (var region in regionsToRedraw)
{
_canvas.Save();
if (!isFullRedraw)
{
_canvas.ClipRect(region);
}
// Clear region
_canvas.Clear(SKColors.White);
// Draw view tree
rootView.Draw(_canvas);
_canvas.Restore();
}
// Draw popup overlays
SkiaView.DrawPopupOverlays(_canvas);
// Draw modal dialogs
if (LinuxDialogService.HasActiveDialog)
{
LinuxDialogService.DrawDialogs(_canvas, new SKRect(0, 0, Width, Height));
}
_canvas.Flush();
// Present to window
if (_gpuAvailable && _grContext != null)
{
_grContext.Submit();
// Swap buffers would happen here via GLX/EGL
}
else if (_softwareBitmap != null)
{
var pixels = _softwareBitmap.GetPixels();
if (pixels != IntPtr.Zero)
{
_window.DrawPixels(pixels, Width, Height, _softwareBitmap.RowBytes);
}
}
}
/// <summary>
/// Gets performance statistics for the GPU context.
/// </summary>
public GpuStats GetStats()
{
if (_grContext == null)
{
return new GpuStats { IsGpuAccelerated = false };
}
// Get resource cache limits from GRContext
_grContext.GetResourceCacheLimits(out var maxResources, out var maxBytes);
return new GpuStats
{
IsGpuAccelerated = true,
MaxTextureSize = 4096, // Common default, SkiaSharp doesn't expose this directly
ResourceCacheUsedBytes = 0, // Would need to track manually
ResourceCacheLimitBytes = maxBytes
};
}
/// <summary>
/// Purges unused GPU resources to free memory.
/// </summary>
public void PurgeResources()
{
_grContext?.PurgeResources();
}
public SKCanvas? GetCanvas() => _canvas;
protected virtual void Dispose(bool disposing)
{
if (!_disposed)
{
if (disposing)
{
_window.Resized -= OnWindowResized;
_window.Exposed -= OnWindowExposed;
_surface?.Dispose();
_renderTarget?.Dispose();
_grContext?.Dispose();
_softwareBitmap?.Dispose();
_softwareCanvas?.Dispose();
}
_disposed = true;
}
}
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
}
/// <summary>
/// GPU performance statistics.
/// </summary>
public class GpuStats
{
public bool IsGpuAccelerated { get; init; }
public int MaxTextureSize { get; init; }
public long ResourceCacheUsedBytes { get; init; }
public long ResourceCacheLimitBytes { get; init; }
public double ResourceCacheUsedMB => ResourceCacheUsedBytes / (1024.0 * 1024.0);
public double ResourceCacheLimitMB => ResourceCacheLimitBytes / (1024.0 * 1024.0);
}

View File

@@ -9,43 +9,22 @@ using System.Runtime.InteropServices;
namespace Microsoft.Maui.Platform.Linux.Rendering;
/// <summary>
/// Manages Skia rendering to an X11 window with dirty region optimization.
/// Manages Skia rendering to an X11 window.
/// </summary>
public class SkiaRenderingEngine : IDisposable
{
private readonly X11Window _window;
private SKBitmap? _bitmap;
private SKBitmap? _backBuffer;
private SKCanvas? _canvas;
private SKImageInfo _imageInfo;
private bool _disposed;
private bool _fullRedrawNeeded = true;
// Dirty region tracking for optimized rendering
private readonly List<SKRect> _dirtyRegions = new();
private readonly object _dirtyLock = new();
private const int MaxDirtyRegions = 32;
private const float RegionMergeThreshold = 0.3f; // Merge if overlap > 30%
public static SkiaRenderingEngine? Current { get; private set; }
public ResourceCache ResourceCache { get; }
public int Width => _imageInfo.Width;
public int Height => _imageInfo.Height;
/// <summary>
/// Gets or sets whether dirty region optimization is enabled.
/// When disabled, full redraws occur (useful for debugging).
/// </summary>
public bool EnableDirtyRegionOptimization { get; set; } = true;
/// <summary>
/// Gets the number of dirty regions in the current frame.
/// </summary>
public int DirtyRegionCount
{
get { lock (_dirtyLock) return _dirtyRegions.Count; }
}
public SkiaRenderingEngine(X11Window window)
{
_window = window;
@@ -61,7 +40,6 @@ public class SkiaRenderingEngine : IDisposable
private void CreateSurface(int width, int height)
{
_bitmap?.Dispose();
_backBuffer?.Dispose();
_canvas?.Dispose();
_imageInfo = new SKImageInfo(
@@ -71,14 +49,9 @@ public class SkiaRenderingEngine : IDisposable
SKAlphaType.Premul);
_bitmap = new SKBitmap(_imageInfo);
_backBuffer = new SKBitmap(_imageInfo);
_canvas = new SKCanvas(_bitmap);
_fullRedrawNeeded = true;
lock (_dirtyLock)
{
_dirtyRegions.Clear();
}
}
private void OnWindowResized(object? sender, (int Width, int Height) size)
@@ -91,117 +64,28 @@ public class SkiaRenderingEngine : IDisposable
_fullRedrawNeeded = true;
}
/// <summary>
/// Marks the entire surface as needing redraw.
/// </summary>
public void InvalidateAll()
{
_fullRedrawNeeded = true;
}
/// <summary>
/// Marks a specific region as needing redraw.
/// Multiple regions are tracked and merged for efficiency.
/// </summary>
public void InvalidateRegion(SKRect region)
{
if (region.IsEmpty || region.Width <= 0 || region.Height <= 0)
return;
// Clamp to surface bounds
region = SKRect.Intersect(region, new SKRect(0, 0, Width, Height));
if (region.IsEmpty)
return;
lock (_dirtyLock)
{
// If we have too many regions, just do a full redraw
if (_dirtyRegions.Count >= MaxDirtyRegions)
{
_fullRedrawNeeded = true;
_dirtyRegions.Clear();
return;
}
// Try to merge with existing regions
for (int i = 0; i < _dirtyRegions.Count; i++)
{
var existing = _dirtyRegions[i];
if (ShouldMergeRegions(existing, region))
{
_dirtyRegions[i] = SKRect.Union(existing, region);
return;
}
}
_dirtyRegions.Add(region);
}
}
private bool ShouldMergeRegions(SKRect a, SKRect b)
{
// Check if regions overlap
var intersection = SKRect.Intersect(a, b);
if (intersection.IsEmpty)
{
// Check if they're adjacent (within a few pixels)
var expanded = new SKRect(a.Left - 4, a.Top - 4, a.Right + 4, a.Bottom + 4);
return expanded.IntersectsWith(b);
}
// Merge if intersection is significant relative to either region
var intersectionArea = intersection.Width * intersection.Height;
var aArea = a.Width * a.Height;
var bArea = b.Width * b.Height;
var minArea = Math.Min(aArea, bArea);
return intersectionArea / minArea >= RegionMergeThreshold;
}
/// <summary>
/// Renders the view tree, optionally using dirty region optimization.
/// </summary>
public void Render(SkiaView rootView)
{
if (_canvas == null || _bitmap == null)
return;
// Measure and arrange
_canvas.Clear(SKColors.White);
// Measure first, then arrange
var availableSize = new SKSize(Width, Height);
rootView.Measure(availableSize);
rootView.Arrange(new SKRect(0, 0, Width, Height));
// Determine what to redraw
List<SKRect> regionsToRedraw;
bool isFullRedraw = _fullRedrawNeeded || !EnableDirtyRegionOptimization;
lock (_dirtyLock)
{
if (isFullRedraw)
{
regionsToRedraw = new List<SKRect> { new SKRect(0, 0, Width, Height) };
_dirtyRegions.Clear();
_fullRedrawNeeded = false;
}
else if (_dirtyRegions.Count == 0)
{
// Nothing to redraw
return;
}
else
{
regionsToRedraw = MergeOverlappingRegions(_dirtyRegions.ToList());
_dirtyRegions.Clear();
}
}
// Render dirty regions
foreach (var region in regionsToRedraw)
{
RenderRegion(rootView, region, isFullRedraw);
}
// Draw popup overlays (always on top, full redraw)
// Draw the view tree
rootView.Draw(_canvas);
// Draw popup overlays (dropdowns, calendars, etc.) on top
SkiaView.DrawPopupOverlays(_canvas);
// Draw modal dialogs on top of everything
@@ -216,67 +100,6 @@ public class SkiaRenderingEngine : IDisposable
PresentToWindow();
}
private void RenderRegion(SkiaView rootView, SKRect region, bool isFullRedraw)
{
if (_canvas == null) return;
_canvas.Save();
if (!isFullRedraw)
{
// Clip to dirty region for partial updates
_canvas.ClipRect(region);
}
// Clear the region
using var clearPaint = new SKPaint { Color = SKColors.White, Style = SKPaintStyle.Fill };
_canvas.DrawRect(region, clearPaint);
// Draw the view tree (views will naturally clip to their bounds)
rootView.Draw(_canvas);
_canvas.Restore();
}
private List<SKRect> MergeOverlappingRegions(List<SKRect> regions)
{
if (regions.Count <= 1)
return regions;
var merged = new List<SKRect>();
var used = new bool[regions.Count];
for (int i = 0; i < regions.Count; i++)
{
if (used[i]) continue;
var current = regions[i];
used[i] = true;
// Keep merging until no more merges possible
bool didMerge;
do
{
didMerge = false;
for (int j = i + 1; j < regions.Count; j++)
{
if (used[j]) continue;
if (ShouldMergeRegions(current, regions[j]))
{
current = SKRect.Union(current, regions[j]);
used[j] = true;
didMerge = true;
}
}
} while (didMerge);
merged.Add(current);
}
return merged;
}
private void PresentToWindow()
{
if (_bitmap == null) return;
@@ -299,7 +122,6 @@ public class SkiaRenderingEngine : IDisposable
_window.Exposed -= OnWindowExposed;
_canvas?.Dispose();
_bitmap?.Dispose();
_backBuffer?.Dispose();
ResourceCache.Dispose();
if (Current == this) Current = null;
}

View File

@@ -1,326 +0,0 @@
// 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;
}
}
}

View File

@@ -1,310 +0,0 @@
// 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());
}
}

View File

@@ -45,7 +45,6 @@ public static class InputMethodServiceFactory
return imePreference.ToLowerInvariant() switch
{
"ibus" => CreateIBusService(),
"fcitx" or "fcitx5" => CreateFcitx5Service(),
"xim" => CreateXIMService(),
"none" => new NullInputMethodService(),
_ => CreateAutoService()
@@ -57,30 +56,13 @@ public static class InputMethodServiceFactory
private static IInputMethodService CreateAutoService()
{
// 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)
// Try IBus first (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())
{
@@ -106,19 +88,6 @@ 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

View File

@@ -2,33 +2,16 @@
// 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) or D-Bus directly.
/// Supports interactive notifications with action callbacks.
/// Linux notification service using notify-send (libnotify).
/// </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)
{
@@ -36,165 +19,6 @@ 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>
@@ -207,72 +31,6 @@ 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>
@@ -451,87 +209,3 @@ 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;
}
}

View File

@@ -1,479 +0,0 @@
// 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; }
}

View File

@@ -1,481 +0,0 @@
// 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; }
}

View File

@@ -1,307 +0,0 @@
// 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);
}
}

View File

@@ -83,7 +83,7 @@ OpenMaui Linux implements a custom SkiaSharp-based rendering stack for .NET MAUI
|------|--------|-------|
| Native Wayland compositor | Deferred | XWayland sufficient for 1.0 |
| GTK4 interop layer | Deferred | Portal approach preferred |
| WebView via WebKitGTK | Deferred | Document as limitation |
| WebView via WebKitGTK | [x] Complete | `Interop/WebKitGtk.cs` + `Views/LinuxWebView.cs` + `Handlers/WebViewHandler.Linux.cs` |
---
@@ -458,11 +458,15 @@ All identified improvements have been implemented:
- `Services/PortalFilePickerService.cs` - xdg-desktop-portal file picker with zenity fallback
- `Services/VirtualizationManager.cs` - View recycling pool for list virtualization
- `Services/Fcitx5InputMethodService.cs` - Fcitx5 input method support
- `Interop/WebKitGtk.cs` - P/Invoke bindings for WebKitGTK library
- `Views/LinuxWebView.cs` - WebKitGTK-based WebView platform control
- `Handlers/WebViewHandler.Linux.cs` - MAUI handler for WebView on Linux
### Files Modified
- `Rendering/SkiaRenderingEngine.cs` - Added dirty region tracking with intelligent merging
- `Services/NotificationService.cs` - Added action callbacks via D-Bus monitoring
- `Services/InputMethodServiceFactory.cs` - Added Fcitx5 support to auto-detection
- `Hosting/LinuxMauiAppBuilderExtensions.cs` - Registered WebViewHandler for WebView control
### Architecture Improvements
1. **Rendering Performance**: Dirty region invalidation reduces redraw area by up to 95%
@@ -470,5 +474,6 @@ All identified improvements have been implemented:
3. **Text Rendering**: Full international text support with font fallback
4. **Platform Integration**: Native file dialogs, theme detection, rich notifications
5. **Input Methods**: IBus + Fcitx5 support covers most Linux desktop configurations
6. **WebView**: Full WebKitGTK integration for HTML/JavaScript rendering with navigation support
*Implementation complete. Ready for 1.0 release pending integration tests.*
*Implementation complete. WebView requires libwebkit2gtk-4.1-0 package on target system.*

87
fix_decompiler.py Normal file
View File

@@ -0,0 +1,87 @@
#!/usr/bin/env python3
"""Fix decompiler artifacts in C# files."""
import re
import sys
import os
def fix_file(filepath):
with open(filepath, 'r') as f:
content = f.read()
original = content
# Pattern 1: Fix ((Type)(ref var))._002Ector(args) on same line as declaration
# Pattern: Type var = default(Type); followed by ((Type)(ref var))._002Ector(args);
# Combine: Type var = default(Type); + var._002Ector(args) -> Type var = new Type(args);
# First, fix the _002Ector pattern to use "new Type(...)"
# Pattern: ((TypeName)(ref varName))._002Ector(args);
pattern_ctor = r'\(\((SK\w+|SKRect|SKSize|SKPoint|SKColor|Thickness|Font|LayoutOptions|SKFontMetrics|RectF|Rect)\)\(ref\s+(\w+)\)\)\._002Ector\(([^;]+)\);'
def replace_ctor(match):
type_name = match.group(1)
var_name = match.group(2)
args = match.group(3)
return f'{var_name} = new {type_name}({args});'
content = re.sub(pattern_ctor, replace_ctor, content)
# Also handle simpler pattern: var._002Ector(args);
pattern_simple = r'(\w+)\._002Ector\(([^;]+)\);'
def replace_simple(match):
var_name = match.group(1)
args = match.group(2)
# We need to figure out the type from context - look for declaration
return f'// FIXME: {var_name} = new TYPE({args});'
# Don't do the simple pattern - it's harder to fix without knowing the type
# Pattern 2: Fix _003F (which is just ?)
content = content.replace('_003F', '?')
# Pattern 2.5: Fix broken nullable cast patterns
# (((??)something) ?? fallback) -> (something ?? fallback)
content = re.sub(r'\(\(\(\?\?\)(\w+\.\w+)\)', r'(\1', content)
content = content.replace('((?)', '((') # Fix broken nullable casts
content = content.replace('(?))', '))') # Fix broken casts
# Pattern 3: Clean up remaining ((Type)(ref var)) patterns without _002Ector
# These become just var
# First handle more types: Font, Thickness, Color, LayoutOptions, GridLength, etc.
types_to_fix = r'SK\w+|Font|Thickness|Color|LayoutOptions|SKFontMetrics|Rectangle|Point|Size|Rect|GridLength|GRGlFramebufferInfo|CornerRadius|RectF'
pattern_ref = r'\(\((' + types_to_fix + r')\)\(ref\s+(\w+)\)\)'
content = re.sub(pattern_ref, r'\2', content)
# Pattern 3.5: Handle static property refs like ((SKColor)(ref SKColors.White))
pattern_static_ref = r'\(\((' + types_to_fix + r')\)\(ref\s+(\w+\.\w+)\)\)'
content = re.sub(pattern_static_ref, r'\2', content)
# Pattern 4: Also handle ViewHandler casts like ((ViewHandler<ISearchBar, SkiaSearchBar>)(object)handler)
# This should stay as-is but the inner (ref x) needs fixing first
# Pattern 5: Fix simple (ref var) that might appear in other contexts
# Pattern: (ref varName) when standalone (not in a cast)
# Skip for now as this could break valid ref usage
if content != original:
with open(filepath, 'w') as f:
f.write(content)
return True
return False
def main():
base_dir = '/Users/nible/Documents/GitHub/maui-linux-main'
count = 0
for root, dirs, files in os.walk(base_dir):
# Skip hidden dirs and .git
dirs[:] = [d for d in dirs if not d.startswith('.')]
for fname in files:
if fname.endswith('.cs'):
filepath = os.path.join(root, fname)
if fix_file(filepath):
print(f'Fixed: {filepath}')
count += 1
print(f'Fixed {count} files')
if __name__ == '__main__':
main()

151
fixfuckup.md Normal file
View File

@@ -0,0 +1,151 @@
# Fix Fuckup Recovery Plan
## What Happened
Code was stored in /tmp directory which got cleared on restart. Recovered code from decompiled VM binaries.
## What Was Lost
The decompiled code has all the **logic** but:
1. **XAML files are gone** - they were compiled to C# code
2. **AppThemeBinding additions** - dark/light mode XAML bindings
3. **Original formatting/comments** - decompiler output is messy
## Recovery Order
### Step 1: Fix maui-linux Library First
The library code is recovered and functional. Build and verify:
```bash
cd ~/Documents/GitHub/maui-linux-main
dotnet build
```
### Step 2: Recreate Sample XAML with AppThemeBinding
#### ShellDemo XAML to Recreate
All pages had AppThemeBinding added for dark/light mode:
- [ ] **AppShell.xaml** - FlyoutHeader with:
- VerticalStackLayout (logo above text)
- Image with AspectFit
- BackgroundColor: `{AppThemeBinding Light=#F0F0F0, Dark=#2A2A2A}`
- TextColor bindings for labels
- [ ] **HomePage.xaml** - AppThemeBinding for:
- BackgroundColor
- TextColor
- Button colors
- [ ] **ButtonsPage.xaml** - AppThemeBinding colors
- [ ] **TextInputPage.xaml** - Entry/Editor theme colors
- [ ] **PickersPage.xaml** - Picker theme colors
- [ ] **ProgressPage.xaml** - ProgressBar theme colors
- [ ] **SelectionPage.xaml** - CheckBox/Switch theme colors
- [ ] **ListsPage.xaml** - CollectionView theme colors
- [ ] **GridsPage.xaml** - Grid theme colors
- [ ] **AboutPage.xaml** - Links with tap gestures, theme colors
- [ ] **DetailPage.xaml** - Theme colors
#### TodoApp XAML to Recreate
- [ ] **TodoListPage.xaml** - AppThemeBinding for:
- Page background
- List item colors
- Button colors
- [ ] **TodoDetailPage.xaml** - Theme colors
- [ ] **NewTodoPage.xaml** - Theme colors
#### XamlBrowser XAML to Recreate
- [ ] **MainPage.xaml** - WebView container with theme
## AppThemeBinding Pattern
All XAML used this pattern:
```xml
<Label TextColor="{AppThemeBinding Light=#333333, Dark=#E0E0E0}" />
<Grid BackgroundColor="{AppThemeBinding Light=#FFFFFF, Dark=#1E1E1E}" />
<Button BackgroundColor="{AppThemeBinding Light=#2196F3, Dark=#1976D2}" />
```
## FlyoutHeader Specifics
The FlyoutHeader had this structure:
```xml
<Shell.FlyoutHeader>
<Grid BackgroundColor="{AppThemeBinding Light=#F0F0F0, Dark=#2A2A2A}"
HeightRequest="160"
Padding="15">
<VerticalStackLayout VerticalOptions="Center"
HorizontalOptions="Center"
Spacing="8">
<Image Source="openmaui_logo.svg"
WidthRequest="70"
HeightRequest="70"
Aspect="AspectFit"/>
<Label Text="OpenMaui"
FontSize="20"
FontAttributes="Bold"
HorizontalOptions="Center"
TextColor="{AppThemeBinding Light=#333333, Dark=#E0E0E0}"/>
<Label Text="Controls Demo"
FontSize="12"
HorizontalOptions="Center"
TextColor="{AppThemeBinding Light=#666666, Dark=#B0B0B0}"/>
</VerticalStackLayout>
</Grid>
</Shell.FlyoutHeader>
```
## Screenshots Needed
User can take screenshots of running app to recreate XAML:
1. **ShellDemo Flyout open** - Light mode
2. **ShellDemo Flyout open** - Dark mode
3. **Each page** - Light and dark mode
4. **TodoApp** - Light and dark mode
## Key Features Recovered in Library
### SkiaShell (1325 lines)
- [x] FlyoutHeaderView, FlyoutHeaderHeight
- [x] FlyoutFooterText, FlyoutFooterHeight
- [x] Flyout scrolling
- [x] All BindableProperties for theming
### X11Window
- [x] Cursor support (XCreateFontCursor, XDefineCursor)
- [x] CursorType enum
### Theme Support
- [x] SystemThemeService
- [x] UserAppTheme detection
- [x] Theme-aware handlers
## File Locations
| Item | Path |
|------|------|
| Library | `~/Documents/GitHub/maui-linux-main` |
| Samples | `~/Documents/GitHub/maui-linux-samples-main` |
| Recovered backup | `~/Documents/GitHub/recovered/` |
## Build & Deploy Commands
```bash
# Build library
cd ~/Documents/GitHub/maui-linux-main
dotnet build
# Build ShellDemo
cd ~/Documents/GitHub/maui-linux-samples-main/ShellDemo
dotnet publish -c Release -r linux-arm64 --self-contained
# Deploy
sshpass -p Basilisk scp -r bin/Release/net9.0/linux-arm64/publish/* marketally@172.16.1.128:~/shelltest/
# Run
sshpass -p Basilisk ssh marketally@172.16.1.128 "cd ~/shelltest && DISPLAY=:0 XAUTHORITY=/run/user/1000/.mutter-Xwaylandauth.* ./ShellDemo"
```
## CRITICAL RULES
1. **NEVER use /tmp** - always use ~/Documents/GitHub/
2. **Commit and push after EVERY significant change**
3. **Only push to dev branch** - main has CI/CD actions

View File

@@ -0,0 +1,78 @@
// ShellDemo App - Comprehensive Control Demo
using Microsoft.Maui.Controls;
namespace ShellDemo;
/// <summary>
/// Main application class with Shell navigation.
/// </summary>
public class App : Application
{
public App()
{
MainPage = new AppShell();
}
}
/// <summary>
/// Shell definition with flyout menu - comprehensive control demo.
/// </summary>
public class AppShell : Shell
{
public AppShell()
{
FlyoutBehavior = FlyoutBehavior.Flyout;
Title = "OpenMaui Controls Demo";
// Register routes for push navigation (pages not in flyout)
Routing.RegisterRoute("detail", typeof(DetailPage));
// Home
Items.Add(CreateFlyoutItem("Home", typeof(HomePage)));
// Buttons Demo
Items.Add(CreateFlyoutItem("Buttons", typeof(ButtonsPage)));
// Text Input Demo
Items.Add(CreateFlyoutItem("Text Input", typeof(TextInputPage)));
// Selection Controls Demo
Items.Add(CreateFlyoutItem("Selection", typeof(SelectionPage)));
// Pickers Demo
Items.Add(CreateFlyoutItem("Pickers", typeof(PickersPage)));
// Lists Demo
Items.Add(CreateFlyoutItem("Lists", typeof(ListsPage)));
// Progress Demo
Items.Add(CreateFlyoutItem("Progress", typeof(ProgressPage)));
// Grids Demo
Items.Add(CreateFlyoutItem("Grids", typeof(GridsPage)));
// About
Items.Add(CreateFlyoutItem("About", typeof(AboutPage)));
}
private FlyoutItem CreateFlyoutItem(string title, Type pageType)
{
// Route is required for Shell.GoToAsync navigation to work
var route = title.Replace(" ", "");
return new FlyoutItem
{
Title = title,
Route = route,
Items =
{
new ShellContent
{
Title = title,
Route = route,
ContentTemplate = new DataTemplate(pageType)
}
}
};
}
}

View File

@@ -0,0 +1,24 @@
// MauiProgram.cs - Shared MAUI app configuration
// Works across all platforms (iOS, Android, Windows, Linux)
using Microsoft.Maui.Hosting;
using Microsoft.Maui.Platform.Linux.Hosting;
namespace ShellDemo;
public static class MauiProgram
{
public static MauiApp CreateMauiApp()
{
var builder = MauiApp.CreateBuilder();
// Configure the app (shared across all platforms)
builder.UseMauiApp<App>();
// Add Linux platform support
// On other platforms, this would be iOS/Android/Windows specific
builder.UseLinux();
return builder.Build();
}
}

View File

@@ -0,0 +1,115 @@
// AboutPage - Information about OpenMaui Linux
using Microsoft.Maui.Controls;
using Microsoft.Maui.Graphics;
namespace ShellDemo;
public class AboutPage : ContentPage
{
public AboutPage()
{
Title = "About";
Content = new ScrollView
{
Content = new VerticalStackLayout
{
Padding = new Thickness(20),
Spacing = 20,
Children =
{
new Label
{
Text = "OpenMaui Linux",
FontSize = 32,
FontAttributes = FontAttributes.Bold,
TextColor = Color.FromArgb("#1A237E"),
HorizontalOptions = LayoutOptions.Center
},
new Label
{
Text = "Version 1.0.0",
FontSize = 16,
TextColor = Colors.Gray,
HorizontalOptions = LayoutOptions.Center
},
new BoxView { HeightRequest = 1, Color = Colors.LightGray },
new Label
{
Text = "OpenMaui Linux brings .NET MAUI to Linux desktops using SkiaSharp for rendering. " +
"It provides a native Linux experience while maintaining compatibility with MAUI's cross-platform API.",
FontSize = 14,
LineBreakMode = LineBreakMode.WordWrap
},
CreateInfoCard("Platform", "Linux (X11/Wayland)"),
CreateInfoCard("Rendering", "SkiaSharp"),
CreateInfoCard("Framework", ".NET MAUI"),
CreateInfoCard("License", "MIT License"),
new BoxView { HeightRequest = 1, Color = Colors.LightGray },
new Label
{
Text = "Features",
FontSize = 20,
FontAttributes = FontAttributes.Bold
},
CreateFeatureItem("Full XAML support with styles and resources"),
CreateFeatureItem("Shell navigation with flyout menus"),
CreateFeatureItem("All standard MAUI controls"),
CreateFeatureItem("Data binding and MVVM"),
CreateFeatureItem("Keyboard and mouse input"),
CreateFeatureItem("High DPI support"),
new BoxView { HeightRequest = 1, Color = Colors.LightGray },
new Label
{
Text = "https://github.com/pablotoledo/OpenMaui-Linux",
FontSize = 12,
TextColor = Colors.Blue,
HorizontalOptions = LayoutOptions.Center
}
}
}
};
}
private Frame CreateInfoCard(string label, string value)
{
return new Frame
{
CornerRadius = 8,
Padding = new Thickness(15),
BackgroundColor = Color.FromArgb("#F5F5F5"),
HasShadow = false,
Content = new HorizontalStackLayout
{
Children =
{
new Label
{
Text = label + ":",
FontAttributes = FontAttributes.Bold,
WidthRequest = 100
},
new Label
{
Text = value,
TextColor = Colors.Gray
}
}
}
};
}
private View CreateFeatureItem(string text)
{
return new HorizontalStackLayout
{
Spacing = 10,
Children =
{
new Label { Text = "✓", TextColor = Color.FromArgb("#4CAF50"), FontSize = 16 },
new Label { Text = text, FontSize = 14 }
}
};
}
}

View File

@@ -0,0 +1,229 @@
// ButtonsPage - Comprehensive Button Control Demo
using Microsoft.Maui.Controls;
using Microsoft.Maui.Graphics;
namespace ShellDemo;
public class ButtonsPage : ContentPage
{
private readonly Label _eventLog;
private int _eventCount = 0;
public ButtonsPage()
{
Title = "Buttons Demo";
_eventLog = new Label
{
Text = "Events will appear here...",
FontSize = 11,
TextColor = Colors.Gray,
LineBreakMode = LineBreakMode.WordWrap
};
Content = new Grid
{
RowDefinitions =
{
new RowDefinition { Height = new GridLength(1, GridUnitType.Star) },
new RowDefinition { Height = new GridLength(120) }
},
Children =
{
CreateMainContent(),
CreateEventLogPanel()
}
};
Grid.SetRow((View)((Grid)Content).Children[0], 0);
Grid.SetRow((View)((Grid)Content).Children[1], 1);
}
private View CreateMainContent()
{
return new ScrollView
{
Content = new VerticalStackLayout
{
Padding = new Thickness(20),
Spacing = 20,
Children =
{
new Label { Text = "Button Styles & Events", FontSize = 24, FontAttributes = FontAttributes.Bold },
// Basic Buttons
CreateSection("Basic Buttons", CreateBasicButtons()),
// Styled Buttons
CreateSection("Styled Buttons", CreateStyledButtons()),
// Button States
CreateSection("Button States", CreateButtonStates()),
// Button with Icons (text simulation)
CreateSection("Button Variations", CreateButtonVariations())
}
}
};
}
private View CreateBasicButtons()
{
var layout = new VerticalStackLayout { Spacing = 10 };
var defaultBtn = new Button { Text = "Default Button" };
defaultBtn.Clicked += (s, e) => LogEvent("Default Button clicked");
defaultBtn.Pressed += (s, e) => LogEvent("Default Button pressed");
defaultBtn.Released += (s, e) => LogEvent("Default Button released");
var textBtn = new Button { Text = "Text Only", BackgroundColor = Colors.Transparent, TextColor = Colors.Blue };
textBtn.Clicked += (s, e) => LogEvent("Text Button clicked");
layout.Children.Add(defaultBtn);
layout.Children.Add(textBtn);
return layout;
}
private View CreateStyledButtons()
{
var layout = new HorizontalStackLayout { Spacing = 10 };
var colors = new[]
{
("#2196F3", "Primary"),
("#4CAF50", "Success"),
("#FF9800", "Warning"),
("#F44336", "Danger"),
("#9C27B0", "Purple")
};
foreach (var (color, name) in colors)
{
var btn = new Button
{
Text = name,
BackgroundColor = Color.FromArgb(color),
TextColor = Colors.White,
CornerRadius = 5
};
btn.Clicked += (s, e) => LogEvent($"{name} button clicked");
layout.Children.Add(btn);
}
return layout;
}
private View CreateButtonStates()
{
var layout = new VerticalStackLayout { Spacing = 10 };
var enabledBtn = new Button { Text = "Enabled Button", IsEnabled = true };
enabledBtn.Clicked += (s, e) => LogEvent("Enabled button clicked");
var disabledBtn = new Button { Text = "Disabled Button", IsEnabled = false };
var toggleBtn = new Button { Text = "Toggle Above Button" };
toggleBtn.Clicked += (s, e) =>
{
disabledBtn.IsEnabled = !disabledBtn.IsEnabled;
disabledBtn.Text = disabledBtn.IsEnabled ? "Now Enabled!" : "Disabled Button";
LogEvent($"Toggled button to: {(disabledBtn.IsEnabled ? "Enabled" : "Disabled")}");
};
layout.Children.Add(enabledBtn);
layout.Children.Add(disabledBtn);
layout.Children.Add(toggleBtn);
return layout;
}
private View CreateButtonVariations()
{
var layout = new VerticalStackLayout { Spacing = 10 };
var wideBtn = new Button
{
Text = "Wide Button",
HorizontalOptions = LayoutOptions.Fill,
BackgroundColor = Color.FromArgb("#673AB7"),
TextColor = Colors.White
};
wideBtn.Clicked += (s, e) => LogEvent("Wide button clicked");
var tallBtn = new Button
{
Text = "Tall Button",
HeightRequest = 60,
BackgroundColor = Color.FromArgb("#009688"),
TextColor = Colors.White
};
tallBtn.Clicked += (s, e) => LogEvent("Tall button clicked");
var roundBtn = new Button
{
Text = "Round",
WidthRequest = 80,
HeightRequest = 80,
CornerRadius = 40,
BackgroundColor = Color.FromArgb("#E91E63"),
TextColor = Colors.White
};
roundBtn.Clicked += (s, e) => LogEvent("Round button clicked");
layout.Children.Add(wideBtn);
layout.Children.Add(tallBtn);
layout.Children.Add(new HorizontalStackLayout { Children = { roundBtn } });
return layout;
}
private Frame CreateSection(string title, View content)
{
return new Frame
{
CornerRadius = 8,
Padding = new Thickness(15),
BackgroundColor = Colors.White,
Content = new VerticalStackLayout
{
Spacing = 10,
Children =
{
new Label { Text = title, FontSize = 16, FontAttributes = FontAttributes.Bold },
content
}
}
};
}
private View CreateEventLogPanel()
{
return new Frame
{
BackgroundColor = Color.FromArgb("#F5F5F5"),
Padding = new Thickness(10),
CornerRadius = 0,
Content = new VerticalStackLayout
{
Children =
{
new Label { Text = "Event Log:", FontSize = 12, FontAttributes = FontAttributes.Bold },
new ScrollView
{
HeightRequest = 80,
Content = _eventLog
}
}
}
};
}
private void LogEvent(string message)
{
_eventCount++;
var timestamp = DateTime.Now.ToString("HH:mm:ss");
_eventLog.Text = $"[{timestamp}] {_eventCount}. {message}\n{_eventLog.Text}";
}
}

View File

@@ -0,0 +1,203 @@
// ControlsPage - Demonstrates various MAUI controls
using Microsoft.Maui.Controls;
using Microsoft.Maui.Graphics;
namespace ShellDemo;
public class ControlsPage : ContentPage
{
public ControlsPage()
{
Title = "Controls";
Content = new ScrollView
{
Content = new VerticalStackLayout
{
Padding = new Thickness(20),
Spacing = 15,
Children =
{
new Label
{
Text = "Control Gallery",
FontSize = 24,
FontAttributes = FontAttributes.Bold
},
// Buttons
CreateSection("Buttons", new View[]
{
CreateButtonRow()
}),
// CheckBox & Switch
CreateSection("Selection", new View[]
{
CreateCheckBoxRow(),
CreateSwitchRow()
}),
// Slider
CreateSection("Slider", new View[]
{
CreateSliderRow()
}),
// Picker
CreateSection("Picker", new View[]
{
CreatePickerRow()
}),
// Progress
CreateSection("Progress", new View[]
{
CreateProgressRow()
})
}
}
};
}
private Frame CreateSection(string title, View[] content)
{
var layout = new VerticalStackLayout { Spacing = 10 };
layout.Children.Add(new Label
{
Text = title,
FontSize = 18,
FontAttributes = FontAttributes.Bold
});
foreach (var view in content)
{
layout.Children.Add(view);
}
return new Frame
{
CornerRadius = 8,
Padding = new Thickness(15),
BackgroundColor = Colors.White,
Content = layout
};
}
private View CreateButtonRow()
{
var resultLabel = new Label { TextColor = Colors.Gray, FontSize = 12 };
var layout = new VerticalStackLayout { Spacing = 10 };
var buttonRow = new HorizontalStackLayout { Spacing = 10 };
var primaryBtn = new Button { Text = "Primary", BackgroundColor = Color.FromArgb("#2196F3"), TextColor = Colors.White };
primaryBtn.Clicked += (s, e) => resultLabel.Text = "Primary clicked!";
var successBtn = new Button { Text = "Success", BackgroundColor = Color.FromArgb("#4CAF50"), TextColor = Colors.White };
successBtn.Clicked += (s, e) => resultLabel.Text = "Success clicked!";
var dangerBtn = new Button { Text = "Danger", BackgroundColor = Color.FromArgb("#F44336"), TextColor = Colors.White };
dangerBtn.Clicked += (s, e) => resultLabel.Text = "Danger clicked!";
buttonRow.Children.Add(primaryBtn);
buttonRow.Children.Add(successBtn);
buttonRow.Children.Add(dangerBtn);
layout.Children.Add(buttonRow);
layout.Children.Add(resultLabel);
return layout;
}
private View CreateCheckBoxRow()
{
var layout = new HorizontalStackLayout { Spacing = 20 };
var cb1 = new CheckBox { IsChecked = true };
var cb2 = new CheckBox { IsChecked = false };
layout.Children.Add(cb1);
layout.Children.Add(new Label { Text = "Option 1", VerticalOptions = LayoutOptions.Center });
layout.Children.Add(cb2);
layout.Children.Add(new Label { Text = "Option 2", VerticalOptions = LayoutOptions.Center });
return layout;
}
private View CreateSwitchRow()
{
var label = new Label { Text = "Off", VerticalOptions = LayoutOptions.Center };
var sw = new Switch { IsToggled = false };
sw.Toggled += (s, e) => label.Text = e.Value ? "On" : "Off";
return new HorizontalStackLayout
{
Spacing = 10,
Children = { sw, label }
};
}
private View CreateSliderRow()
{
var label = new Label { Text = "Value: 50" };
var slider = new Slider { Minimum = 0, Maximum = 100, Value = 50 };
slider.ValueChanged += (s, e) => label.Text = $"Value: {(int)e.NewValue}";
return new VerticalStackLayout
{
Spacing = 5,
Children = { slider, label }
};
}
private View CreatePickerRow()
{
var label = new Label { Text = "Selected: (none)", TextColor = Colors.Gray };
var picker = new Picker { Title = "Select a fruit" };
picker.Items.Add("Apple");
picker.Items.Add("Banana");
picker.Items.Add("Cherry");
picker.Items.Add("Date");
picker.Items.Add("Elderberry");
picker.SelectedIndexChanged += (s, e) =>
{
if (picker.SelectedIndex >= 0)
label.Text = $"Selected: {picker.Items[picker.SelectedIndex]}";
};
return new VerticalStackLayout
{
Spacing = 5,
Children = { picker, label }
};
}
private View CreateProgressRow()
{
var progress = new ProgressBar { Progress = 0.7 };
var activity = new ActivityIndicator { IsRunning = true };
return new VerticalStackLayout
{
Spacing = 10,
Children =
{
progress,
new Label { Text = "70% Complete", FontSize = 12, TextColor = Colors.Gray },
new HorizontalStackLayout
{
Spacing = 10,
Children =
{
activity,
new Label { Text = "Loading...", VerticalOptions = LayoutOptions.Center, TextColor = Colors.Gray }
}
}
}
};
}
}

View File

@@ -0,0 +1,123 @@
// DetailPage - Demonstrates push/pop navigation
using Microsoft.Maui.Controls;
using Microsoft.Maui.Graphics;
using Microsoft.Maui.Platform.Linux.Hosting;
namespace ShellDemo;
/// <summary>
/// A detail page that can be pushed onto the navigation stack.
/// </summary>
public class DetailPage : ContentPage
{
private readonly string _itemName;
public DetailPage() : this("Detail Item")
{
}
public DetailPage(string itemName)
{
_itemName = itemName;
Title = "Detail Page";
Content = new VerticalStackLayout
{
Padding = new Thickness(30),
Spacing = 20,
VerticalOptions = LayoutOptions.Center,
Children =
{
new Label
{
Text = "Pushed Page",
FontSize = 28,
FontAttributes = FontAttributes.Bold,
HorizontalOptions = LayoutOptions.Center,
TextColor = Color.FromArgb("#9C27B0")
},
new Label
{
Text = $"You navigated to: {_itemName}",
FontSize = 16,
HorizontalOptions = LayoutOptions.Center
},
new Label
{
Text = "This page was pushed onto the navigation stack using Shell.Current.GoToAsync()",
FontSize = 14,
TextColor = Colors.Gray,
HorizontalTextAlignment = TextAlignment.Center,
LineBreakMode = LineBreakMode.WordWrap
},
new BoxView
{
HeightRequest = 2,
Color = Color.FromArgb("#E0E0E0"),
Margin = new Thickness(0, 20)
},
CreateBackButton(),
new Label
{
Text = "Use the back button above or the hardware/gesture back to pop this page",
FontSize = 12,
TextColor = Colors.Gray,
HorizontalTextAlignment = TextAlignment.Center,
Margin = new Thickness(0, 20, 0, 0)
}
}
};
}
private Button CreateBackButton()
{
var backBtn = new Button
{
Text = "Go Back (Pop)",
BackgroundColor = Color.FromArgb("#9C27B0"),
TextColor = Colors.White,
HorizontalOptions = LayoutOptions.Center,
Padding = new Thickness(30, 10)
};
backBtn.Clicked += (s, e) =>
{
// Pop this page off the navigation stack using LinuxViewRenderer
Console.WriteLine("[DetailPage] Go Back clicked");
var success = LinuxViewRenderer.PopPage();
Console.WriteLine($"[DetailPage] PopPage result: {success}");
};
return backBtn;
}
}
/// <summary>
/// Query property for passing data to DetailPage.
/// </summary>
[QueryProperty(nameof(ItemName), "item")]
public class DetailPageWithQuery : DetailPage
{
private string _itemName = "Item";
public string ItemName
{
get => _itemName;
set
{
_itemName = value;
// Update the title when the property is set
Title = $"Detail: {value}";
}
}
public DetailPageWithQuery() : base()
{
}
}

View File

@@ -0,0 +1,594 @@
// GridsPage - Demonstrates Grid layouts with various options
using Microsoft.Maui.Controls;
using Microsoft.Maui.Graphics;
namespace ShellDemo;
public class GridsPage : ContentPage
{
public GridsPage()
{
Title = "Grids";
Content = new ScrollView
{
Orientation = ScrollOrientation.Both,
Content = new VerticalStackLayout
{
Spacing = 25,
Children =
{
CreateSectionHeader("Basic Grid (2x2)"),
CreateBasicGrid(),
CreateSectionHeader("Column Definitions"),
CreateColumnDefinitionsDemo(),
CreateSectionHeader("Row Definitions"),
CreateRowDefinitionsDemo(),
CreateSectionHeader("Auto Rows (Empty vs Content)"),
CreateAutoRowsDemo(),
CreateSectionHeader("Star Sizing (Proportional)"),
CreateStarSizingDemo(),
CreateSectionHeader("Row & Column Spacing"),
CreateSpacingDemo(),
CreateSectionHeader("Row & Column Span"),
CreateSpanDemo(),
CreateSectionHeader("Mixed Sizing"),
CreateMixedSizingDemo(),
CreateSectionHeader("Nested Grids"),
CreateNestedGridDemo(),
new BoxView { HeightRequest = 20 } // Bottom padding
}
}
};
}
private Label CreateSectionHeader(string text)
{
return new Label
{
Text = text,
FontSize = 18,
FontAttributes = FontAttributes.Bold,
TextColor = Color.FromArgb("#2196F3"),
Margin = new Thickness(0, 10, 0, 5)
};
}
private View CreateBasicGrid()
{
var grid = new Grid
{
RowDefinitions =
{
new RowDefinition { Height = GridLength.Auto },
new RowDefinition { Height = GridLength.Auto }
},
ColumnDefinitions =
{
new ColumnDefinition { Width = GridLength.Star },
new ColumnDefinition { Width = GridLength.Star }
},
BackgroundColor = Color.FromArgb("#F5F5F5")
};
var cell1 = CreateCell("Row 0, Col 0", "#E3F2FD");
var cell2 = CreateCell("Row 0, Col 1", "#E8F5E9");
var cell3 = CreateCell("Row 1, Col 0", "#FFF3E0");
var cell4 = CreateCell("Row 1, Col 1", "#FCE4EC");
Grid.SetRow(cell1, 0); Grid.SetColumn(cell1, 0);
Grid.SetRow(cell2, 0); Grid.SetColumn(cell2, 1);
Grid.SetRow(cell3, 1); Grid.SetColumn(cell3, 0);
Grid.SetRow(cell4, 1); Grid.SetColumn(cell4, 1);
grid.Children.Add(cell1);
grid.Children.Add(cell2);
grid.Children.Add(cell3);
grid.Children.Add(cell4);
return CreateDemoContainer(grid, "Equal columns using Star sizing");
}
private View CreateColumnDefinitionsDemo()
{
var stack = new VerticalStackLayout { Spacing = 15 };
// Auto width columns
var autoGrid = new Grid
{
ColumnDefinitions =
{
new ColumnDefinition { Width = GridLength.Auto },
new ColumnDefinition { Width = GridLength.Auto },
new ColumnDefinition { Width = GridLength.Auto }
},
BackgroundColor = Color.FromArgb("#F5F5F5")
};
var a1 = CreateCell("Auto", "#BBDEFB");
var a2 = CreateCell("Auto Width", "#C8E6C9");
var a3 = CreateCell("A", "#FFECB3");
Grid.SetColumn(a1, 0);
Grid.SetColumn(a2, 1);
Grid.SetColumn(a3, 2);
autoGrid.Children.Add(a1);
autoGrid.Children.Add(a2);
autoGrid.Children.Add(a3);
stack.Children.Add(new Label { Text = "Auto: Sizes to content", FontSize = 12, TextColor = Colors.Gray });
stack.Children.Add(autoGrid);
// Absolute width columns
var absoluteGrid = new Grid
{
ColumnDefinitions =
{
new ColumnDefinition { Width = new GridLength(50) },
new ColumnDefinition { Width = new GridLength(100) },
new ColumnDefinition { Width = new GridLength(150) }
},
BackgroundColor = Color.FromArgb("#F5F5F5")
};
var b1 = CreateCell("50px", "#BBDEFB");
var b2 = CreateCell("100px", "#C8E6C9");
var b3 = CreateCell("150px", "#FFECB3");
Grid.SetColumn(b1, 0);
Grid.SetColumn(b2, 1);
Grid.SetColumn(b3, 2);
absoluteGrid.Children.Add(b1);
absoluteGrid.Children.Add(b2);
absoluteGrid.Children.Add(b3);
stack.Children.Add(new Label { Text = "Absolute: Fixed pixel widths (50, 100, 150)", FontSize = 12, TextColor = Colors.Gray, Margin = new Thickness(0, 10, 0, 0) });
stack.Children.Add(absoluteGrid);
return stack;
}
private View CreateRowDefinitionsDemo()
{
var grid = new Grid
{
WidthRequest = 200,
RowDefinitions =
{
new RowDefinition { Height = new GridLength(30) },
new RowDefinition { Height = new GridLength(50) },
new RowDefinition { Height = GridLength.Auto },
new RowDefinition { Height = new GridLength(40) }
},
ColumnDefinitions =
{
new ColumnDefinition { Width = GridLength.Star }
},
BackgroundColor = Color.FromArgb("#F5F5F5")
};
var r1 = CreateCell("30px height", "#BBDEFB");
var r2 = CreateCell("50px height", "#C8E6C9");
var r3 = CreateCell("Auto height\n(fits content)", "#FFECB3");
var r4 = CreateCell("40px height", "#F8BBD9");
Grid.SetRow(r1, 0);
Grid.SetRow(r2, 1);
Grid.SetRow(r3, 2);
Grid.SetRow(r4, 3);
grid.Children.Add(r1);
grid.Children.Add(r2);
grid.Children.Add(r3);
grid.Children.Add(r4);
return CreateDemoContainer(grid, "Different row heights: 30px, 50px, Auto, 40px");
}
private View CreateAutoRowsDemo()
{
var stack = new VerticalStackLayout { Spacing = 15 };
// Grid with empty Auto row
var emptyAutoGrid = new Grid
{
WidthRequest = 250,
RowDefinitions =
{
new RowDefinition { Height = new GridLength(40) },
new RowDefinition { Height = GridLength.Auto }, // Empty - should collapse
new RowDefinition { Height = new GridLength(40) }
},
ColumnDefinitions =
{
new ColumnDefinition { Width = GridLength.Star }
},
BackgroundColor = Color.FromArgb("#E0E0E0")
};
var r1 = CreateCell("Row 0: 40px", "#BBDEFB");
// Row 1 is Auto with NO content - should be 0 height
var r3 = CreateCell("Row 2: 40px", "#C8E6C9");
Grid.SetRow(r1, 0);
Grid.SetRow(r3, 2); // Skip row 1
emptyAutoGrid.Children.Add(r1);
emptyAutoGrid.Children.Add(r3);
stack.Children.Add(new Label { Text = "Empty Auto row (Row 1) should collapse to 0 height:", FontSize = 12, TextColor = Colors.Gray });
stack.Children.Add(emptyAutoGrid);
// Grid with Auto row that has content
var contentAutoGrid = new Grid
{
WidthRequest = 250,
RowDefinitions =
{
new RowDefinition { Height = new GridLength(40) },
new RowDefinition { Height = GridLength.Auto }, // Has content
new RowDefinition { Height = new GridLength(40) }
},
ColumnDefinitions =
{
new ColumnDefinition { Width = GridLength.Star }
},
BackgroundColor = Color.FromArgb("#E0E0E0")
};
var c1 = CreateCell("Row 0: 40px", "#BBDEFB");
var c2 = CreateCell("Row 1: Auto (sized to this content)", "#FFECB3");
var c3 = CreateCell("Row 2: 40px", "#C8E6C9");
Grid.SetRow(c1, 0);
Grid.SetRow(c2, 1);
Grid.SetRow(c3, 2);
contentAutoGrid.Children.Add(c1);
contentAutoGrid.Children.Add(c2);
contentAutoGrid.Children.Add(c3);
stack.Children.Add(new Label { Text = "Auto row with content sizes to fit:", FontSize = 12, TextColor = Colors.Gray, Margin = new Thickness(0, 10, 0, 0) });
stack.Children.Add(contentAutoGrid);
return stack;
}
private View CreateStarSizingDemo()
{
var grid = new Grid
{
ColumnDefinitions =
{
new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) },
new ColumnDefinition { Width = new GridLength(2, GridUnitType.Star) },
new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) }
},
BackgroundColor = Color.FromArgb("#F5F5F5")
};
var s1 = CreateCell("1*", "#BBDEFB");
var s2 = CreateCell("2* (double)", "#C8E6C9");
var s3 = CreateCell("1*", "#FFECB3");
Grid.SetColumn(s1, 0);
Grid.SetColumn(s2, 1);
Grid.SetColumn(s3, 2);
grid.Children.Add(s1);
grid.Children.Add(s2);
grid.Children.Add(s3);
return CreateDemoContainer(grid, "Star proportions: 1* | 2* | 1* = 25% | 50% | 25%");
}
private View CreateSpacingDemo()
{
var stack = new VerticalStackLayout { Spacing = 15 };
// No spacing
var noSpacing = new Grid
{
RowSpacing = 0,
ColumnSpacing = 0,
RowDefinitions =
{
new RowDefinition { Height = GridLength.Auto },
new RowDefinition { Height = GridLength.Auto }
},
ColumnDefinitions =
{
new ColumnDefinition { Width = GridLength.Star },
new ColumnDefinition { Width = GridLength.Star }
}
};
AddFourCells(noSpacing);
stack.Children.Add(new Label { Text = "No spacing (RowSpacing=0, ColumnSpacing=0)", FontSize = 12, TextColor = Colors.Gray });
stack.Children.Add(noSpacing);
// With spacing
var withSpacing = new Grid
{
RowSpacing = 10,
ColumnSpacing = 10,
RowDefinitions =
{
new RowDefinition { Height = GridLength.Auto },
new RowDefinition { Height = GridLength.Auto }
},
ColumnDefinitions =
{
new ColumnDefinition { Width = GridLength.Star },
new ColumnDefinition { Width = GridLength.Star }
}
};
AddFourCells(withSpacing);
stack.Children.Add(new Label { Text = "With spacing (RowSpacing=10, ColumnSpacing=10)", FontSize = 12, TextColor = Colors.Gray, Margin = new Thickness(0, 10, 0, 0) });
stack.Children.Add(withSpacing);
// Different row/column spacing
var mixedSpacing = new Grid
{
RowSpacing = 5,
ColumnSpacing = 20,
RowDefinitions =
{
new RowDefinition { Height = GridLength.Auto },
new RowDefinition { Height = GridLength.Auto }
},
ColumnDefinitions =
{
new ColumnDefinition { Width = GridLength.Star },
new ColumnDefinition { Width = GridLength.Star }
}
};
AddFourCells(mixedSpacing);
stack.Children.Add(new Label { Text = "Mixed spacing (RowSpacing=5, ColumnSpacing=20)", FontSize = 12, TextColor = Colors.Gray, Margin = new Thickness(0, 10, 0, 0) });
stack.Children.Add(mixedSpacing);
return stack;
}
private View CreateSpanDemo()
{
var grid = new Grid
{
RowSpacing = 5,
ColumnSpacing = 5,
RowDefinitions =
{
new RowDefinition { Height = GridLength.Auto },
new RowDefinition { Height = GridLength.Auto },
new RowDefinition { Height = GridLength.Auto }
},
ColumnDefinitions =
{
new ColumnDefinition { Width = GridLength.Star },
new ColumnDefinition { Width = GridLength.Star },
new ColumnDefinition { Width = GridLength.Star }
}
};
// Spanning header
var header = CreateCell("ColumnSpan=3 (Header)", "#1976D2", Colors.White);
Grid.SetRow(header, 0);
Grid.SetColumn(header, 0);
Grid.SetColumnSpan(header, 3);
// Left sidebar spanning 2 rows
var sidebar = CreateCell("RowSpan=2\n(Sidebar)", "#388E3C", Colors.White);
Grid.SetRow(sidebar, 1);
Grid.SetColumn(sidebar, 0);
Grid.SetRowSpan(sidebar, 2);
// Content cells
var content1 = CreateCell("Content 1", "#E3F2FD");
Grid.SetRow(content1, 1);
Grid.SetColumn(content1, 1);
var content2 = CreateCell("Content 2", "#E8F5E9");
Grid.SetRow(content2, 1);
Grid.SetColumn(content2, 2);
var content3 = CreateCell("Content 3", "#FFF3E0");
Grid.SetRow(content3, 2);
Grid.SetColumn(content3, 1);
var content4 = CreateCell("Content 4", "#FCE4EC");
Grid.SetRow(content4, 2);
Grid.SetColumn(content4, 2);
grid.Children.Add(header);
grid.Children.Add(sidebar);
grid.Children.Add(content1);
grid.Children.Add(content2);
grid.Children.Add(content3);
grid.Children.Add(content4);
return CreateDemoContainer(grid, "Header spans 3 columns, Sidebar spans 2 rows");
}
private View CreateMixedSizingDemo()
{
var grid = new Grid
{
ColumnSpacing = 5,
ColumnDefinitions =
{
new ColumnDefinition { Width = new GridLength(60) }, // Fixed
new ColumnDefinition { Width = GridLength.Star }, // Fill
new ColumnDefinition { Width = GridLength.Auto }, // Auto
new ColumnDefinition { Width = new GridLength(60) } // Fixed
},
BackgroundColor = Color.FromArgb("#F5F5F5")
};
var c1 = CreateCell("60px", "#BBDEFB");
var c2 = CreateCell("Star (fills remaining)", "#C8E6C9");
var c3 = CreateCell("Auto", "#FFECB3");
var c4 = CreateCell("60px", "#F8BBD9");
Grid.SetColumn(c1, 0);
Grid.SetColumn(c2, 1);
Grid.SetColumn(c3, 2);
Grid.SetColumn(c4, 3);
grid.Children.Add(c1);
grid.Children.Add(c2);
grid.Children.Add(c3);
grid.Children.Add(c4);
return CreateDemoContainer(grid, "Mixed: 60px | Star | Auto | 60px");
}
private View CreateNestedGridDemo()
{
var outerGrid = new Grid
{
RowSpacing = 10,
ColumnSpacing = 10,
RowDefinitions =
{
new RowDefinition { Height = GridLength.Auto },
new RowDefinition { Height = GridLength.Auto }
},
ColumnDefinitions =
{
new ColumnDefinition { Width = GridLength.Star },
new ColumnDefinition { Width = GridLength.Star }
},
BackgroundColor = Color.FromArgb("#E0E0E0"),
Padding = new Thickness(10)
};
// Nested grid 1
var innerGrid1 = new Grid
{
RowSpacing = 2,
ColumnSpacing = 2,
RowDefinitions =
{
new RowDefinition { Height = GridLength.Auto },
new RowDefinition { Height = GridLength.Auto }
},
ColumnDefinitions =
{
new ColumnDefinition { Width = GridLength.Star },
new ColumnDefinition { Width = GridLength.Star }
}
};
var i1a = CreateCell("A", "#BBDEFB", null, 8);
var i1b = CreateCell("B", "#90CAF9", null, 8);
var i1c = CreateCell("C", "#64B5F6", null, 8);
var i1d = CreateCell("D", "#42A5F5", null, 8);
Grid.SetRow(i1a, 0); Grid.SetColumn(i1a, 0);
Grid.SetRow(i1b, 0); Grid.SetColumn(i1b, 1);
Grid.SetRow(i1c, 1); Grid.SetColumn(i1c, 0);
Grid.SetRow(i1d, 1); Grid.SetColumn(i1d, 1);
innerGrid1.Children.Add(i1a);
innerGrid1.Children.Add(i1b);
innerGrid1.Children.Add(i1c);
innerGrid1.Children.Add(i1d);
// Nested grid 2
var innerGrid2 = new Grid
{
RowSpacing = 2,
ColumnSpacing = 2,
RowDefinitions =
{
new RowDefinition { Height = GridLength.Auto },
new RowDefinition { Height = GridLength.Auto }
},
ColumnDefinitions =
{
new ColumnDefinition { Width = GridLength.Star },
new ColumnDefinition { Width = GridLength.Star }
}
};
var i2a = CreateCell("1", "#C8E6C9", null, 8);
var i2b = CreateCell("2", "#A5D6A7", null, 8);
var i2c = CreateCell("3", "#81C784", null, 8);
var i2d = CreateCell("4", "#66BB6A", null, 8);
Grid.SetRow(i2a, 0); Grid.SetColumn(i2a, 0);
Grid.SetRow(i2b, 0); Grid.SetColumn(i2b, 1);
Grid.SetRow(i2c, 1); Grid.SetColumn(i2c, 0);
Grid.SetRow(i2d, 1); Grid.SetColumn(i2d, 1);
innerGrid2.Children.Add(i2a);
innerGrid2.Children.Add(i2b);
innerGrid2.Children.Add(i2c);
innerGrid2.Children.Add(i2d);
Grid.SetRow(innerGrid1, 0); Grid.SetColumn(innerGrid1, 0);
Grid.SetRow(innerGrid2, 0); Grid.SetColumn(innerGrid2, 1);
var label1 = new Label { Text = "Outer Grid Row 1", HorizontalOptions = LayoutOptions.Center };
var label2 = new Label { Text = "Spans both columns", HorizontalOptions = LayoutOptions.Center };
Grid.SetRow(label1, 1); Grid.SetColumn(label1, 0);
Grid.SetRow(label2, 1); Grid.SetColumn(label2, 1);
outerGrid.Children.Add(innerGrid1);
outerGrid.Children.Add(innerGrid2);
outerGrid.Children.Add(label1);
outerGrid.Children.Add(label2);
return CreateDemoContainer(outerGrid, "Outer grid contains two nested 2x2 grids");
}
private Border CreateCell(string text, string bgColor, Color? textColor = null, float fontSize = 12)
{
return new Border
{
BackgroundColor = Color.FromArgb(bgColor),
Padding = new Thickness(10, 8),
StrokeThickness = 0,
Content = new Label
{
Text = text,
FontSize = fontSize,
TextColor = textColor ?? Colors.Black,
HorizontalTextAlignment = TextAlignment.Center,
VerticalTextAlignment = TextAlignment.Center
}
};
}
private void AddFourCells(Grid grid)
{
var c1 = CreateCell("0,0", "#BBDEFB");
var c2 = CreateCell("0,1", "#C8E6C9");
var c3 = CreateCell("1,0", "#FFECB3");
var c4 = CreateCell("1,1", "#F8BBD9");
Grid.SetRow(c1, 0); Grid.SetColumn(c1, 0);
Grid.SetRow(c2, 0); Grid.SetColumn(c2, 1);
Grid.SetRow(c3, 1); Grid.SetColumn(c3, 0);
Grid.SetRow(c4, 1); Grid.SetColumn(c4, 1);
grid.Children.Add(c1);
grid.Children.Add(c2);
grid.Children.Add(c3);
grid.Children.Add(c4);
}
private View CreateDemoContainer(View content, string description)
{
return new VerticalStackLayout
{
Spacing = 5,
Children =
{
new Label { Text = description, FontSize = 12, TextColor = Colors.Gray },
content
}
};
}
}

View File

@@ -0,0 +1,265 @@
// HomePage - Welcome page for the demo
using Microsoft.Maui.Controls;
using Microsoft.Maui.Graphics;
using Microsoft.Maui.Platform.Linux.Hosting;
namespace ShellDemo;
public class HomePage : ContentPage
{
public HomePage()
{
Title = "Home";
Content = new ScrollView
{
Orientation = ScrollOrientation.Both, // Enable horizontal scrolling when window is too narrow
Content = new VerticalStackLayout
{
Padding = new Thickness(30),
Spacing = 20,
Children =
{
new Label
{
Text = "OpenMaui Linux",
FontSize = 32,
FontAttributes = FontAttributes.Bold,
HorizontalOptions = LayoutOptions.Center,
TextColor = Color.FromArgb("#2196F3")
},
new Label
{
Text = "Controls Demo",
FontSize = 20,
HorizontalOptions = LayoutOptions.Center,
TextColor = Colors.Gray
},
new BoxView
{
HeightRequest = 2,
Color = Color.FromArgb("#E0E0E0"),
Margin = new Thickness(0, 10)
},
new Label
{
Text = "Welcome to the comprehensive controls demonstration for OpenMaui Linux. " +
"This app showcases all the major UI controls available in the framework.",
FontSize = 14,
LineBreakMode = LineBreakMode.WordWrap,
HorizontalTextAlignment = TextAlignment.Center
},
CreateFeatureSection(),
new Label
{
Text = "Use the flyout menu (swipe from left or tap the hamburger icon) to navigate between different control demos.",
FontSize = 12,
TextColor = Colors.Gray,
LineBreakMode = LineBreakMode.WordWrap,
HorizontalTextAlignment = TextAlignment.Center,
Margin = new Thickness(0, 20, 0, 0)
},
CreateQuickLinksSection(),
CreateNavigationDemoSection()
}
}
};
}
private View CreateFeatureSection()
{
var grid = new Grid
{
ColumnDefinitions =
{
new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) },
new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) }
},
RowDefinitions =
{
new RowDefinition { Height = GridLength.Auto },
new RowDefinition { Height = GridLength.Auto },
new RowDefinition { Height = GridLength.Auto }
},
ColumnSpacing = 15,
RowSpacing = 15,
Margin = new Thickness(0, 20)
};
var features = new[]
{
("Buttons", "Various button styles and events"),
("Text Input", "Entry, Editor, SearchBar"),
("Selection", "CheckBox, Switch, Slider"),
("Pickers", "Picker, DatePicker, TimePicker"),
("Lists", "CollectionView with selection"),
("Progress", "ProgressBar, ActivityIndicator")
};
for (int i = 0; i < features.Length; i++)
{
var (title, desc) = features[i];
var card = CreateFeatureCard(title, desc);
Grid.SetRow(card, i / 2);
Grid.SetColumn(card, i % 2);
grid.Children.Add(card);
}
return grid;
}
private Frame CreateFeatureCard(string title, string description)
{
return new Frame
{
CornerRadius = 8,
Padding = new Thickness(15),
BackgroundColor = Colors.White,
HasShadow = true,
Content = new VerticalStackLayout
{
Spacing = 5,
Children =
{
new Label
{
Text = title,
FontSize = 14,
FontAttributes = FontAttributes.Bold,
TextColor = Color.FromArgb("#2196F3")
},
new Label
{
Text = description,
FontSize = 11,
TextColor = Colors.Gray,
LineBreakMode = LineBreakMode.WordWrap
}
}
}
};
}
private View CreateQuickLinksSection()
{
var layout = new VerticalStackLayout
{
Spacing = 10,
Margin = new Thickness(0, 20, 0, 0)
};
layout.Children.Add(new Label
{
Text = "Quick Actions",
FontSize = 16,
FontAttributes = FontAttributes.Bold,
HorizontalOptions = LayoutOptions.Center
});
var buttonRow = new HorizontalStackLayout
{
Spacing = 10,
HorizontalOptions = LayoutOptions.Center
};
var buttonsBtn = new Button
{
Text = "Try Buttons",
BackgroundColor = Color.FromArgb("#2196F3"),
TextColor = Colors.White
};
buttonsBtn.Clicked += (s, e) => LinuxViewRenderer.NavigateToRoute("Buttons");
var listsBtn = new Button
{
Text = "Try Lists",
BackgroundColor = Color.FromArgb("#4CAF50"),
TextColor = Colors.White
};
listsBtn.Clicked += (s, e) => LinuxViewRenderer.NavigateToRoute("Lists");
buttonRow.Children.Add(buttonsBtn);
buttonRow.Children.Add(listsBtn);
layout.Children.Add(buttonRow);
return layout;
}
private View CreateNavigationDemoSection()
{
var frame = new Frame
{
CornerRadius = 8,
Padding = new Thickness(20),
BackgroundColor = Color.FromArgb("#F3E5F5"),
Margin = new Thickness(0, 20, 0, 0),
Content = new VerticalStackLayout
{
Spacing = 15,
Children =
{
new Label
{
Text = "Navigation Stack Demo",
FontSize = 18,
FontAttributes = FontAttributes.Bold,
TextColor = Color.FromArgb("#9C27B0"),
HorizontalOptions = LayoutOptions.Center
},
new Label
{
Text = "Demonstrate push/pop navigation using Shell.GoToAsync()",
FontSize = 12,
TextColor = Colors.Gray,
HorizontalTextAlignment = TextAlignment.Center
},
CreatePushButton("Push Detail Page", "detail"),
new Label
{
Text = "Click the button to push a new page onto the navigation stack. " +
"Use the back button or 'Go Back' to pop it off.",
FontSize = 11,
TextColor = Colors.Gray,
HorizontalTextAlignment = TextAlignment.Center,
LineBreakMode = LineBreakMode.WordWrap
}
}
}
};
return frame;
}
private Button CreatePushButton(string text, string route)
{
var btn = new Button
{
Text = text,
BackgroundColor = Color.FromArgb("#9C27B0"),
TextColor = Colors.White,
HorizontalOptions = LayoutOptions.Center,
Padding = new Thickness(30, 10)
};
btn.Clicked += (s, e) =>
{
Console.WriteLine($"[HomePage] Push button clicked, navigating to {route}");
// Use LinuxViewRenderer.PushPage for Skia-based navigation
var success = LinuxViewRenderer.PushPage(new DetailPage());
Console.WriteLine($"[HomePage] PushPage result: {success}");
};
return btn;
}
}

View File

@@ -0,0 +1,249 @@
// ListsPage - CollectionView and ListView Demo
using Microsoft.Maui.Controls;
using Microsoft.Maui.Graphics;
namespace ShellDemo;
public class ListsPage : ContentPage
{
private readonly Label _eventLog;
private int _eventCount = 0;
public ListsPage()
{
Title = "Lists";
_eventLog = new Label
{
Text = "Events will appear here...",
FontSize = 11,
TextColor = Colors.Gray,
LineBreakMode = LineBreakMode.WordWrap
};
Content = new Grid
{
RowDefinitions =
{
new RowDefinition { Height = new GridLength(1, GridUnitType.Star) },
new RowDefinition { Height = new GridLength(120) }
},
Children =
{
CreateMainContent(),
CreateEventLogPanel()
}
};
Grid.SetRow((View)((Grid)Content).Children[0], 0);
Grid.SetRow((View)((Grid)Content).Children[1], 1);
}
private View CreateMainContent()
{
return new ScrollView
{
Content = new VerticalStackLayout
{
Padding = new Thickness(20),
Spacing = 20,
Children =
{
new Label { Text = "List Controls", FontSize = 24, FontAttributes = FontAttributes.Bold },
CreateSection("CollectionView - Fruits", CreateFruitsCollectionView()),
CreateSection("CollectionView - Colors", CreateColorsCollectionView()),
CreateSection("CollectionView - Contacts", CreateContactsCollectionView())
}
}
};
}
private View CreateFruitsCollectionView()
{
var layout = new VerticalStackLayout { Spacing = 10 };
var fruits = new List<string>
{
"Apple", "Banana", "Cherry", "Date", "Elderberry",
"Fig", "Grape", "Honeydew", "Kiwi", "Lemon",
"Mango", "Nectarine", "Orange", "Papaya", "Quince"
};
var selectedLabel = new Label { Text = "Tap a fruit to select", TextColor = Colors.Gray };
var collectionView = new CollectionView
{
ItemsSource = fruits,
HeightRequest = 200,
SelectionMode = SelectionMode.Single,
BackgroundColor = Color.FromArgb("#FAFAFA")
};
collectionView.SelectionChanged += (s, e) =>
{
if (e.CurrentSelection.Count > 0)
{
var item = e.CurrentSelection[0]?.ToString();
selectedLabel.Text = $"Selected: {item}";
LogEvent($"Fruit selected: {item}");
}
};
layout.Children.Add(collectionView);
layout.Children.Add(selectedLabel);
return layout;
}
private View CreateColorsCollectionView()
{
var layout = new VerticalStackLayout { Spacing = 10 };
var colors = new List<ColorItem>
{
new("Red", "#F44336"),
new("Pink", "#E91E63"),
new("Purple", "#9C27B0"),
new("Deep Purple", "#673AB7"),
new("Indigo", "#3F51B5"),
new("Blue", "#2196F3"),
new("Cyan", "#00BCD4"),
new("Teal", "#009688"),
new("Green", "#4CAF50"),
new("Light Green", "#8BC34A"),
new("Lime", "#CDDC39"),
new("Yellow", "#FFEB3B"),
new("Amber", "#FFC107"),
new("Orange", "#FF9800"),
new("Deep Orange", "#FF5722")
};
var collectionView = new CollectionView
{
ItemsSource = colors,
HeightRequest = 180,
SelectionMode = SelectionMode.Single,
BackgroundColor = Colors.White
};
collectionView.SelectionChanged += (s, e) =>
{
if (e.CurrentSelection.Count > 0 && e.CurrentSelection[0] is ColorItem item)
{
LogEvent($"Color selected: {item.Name} ({item.Hex})");
}
};
layout.Children.Add(collectionView);
layout.Children.Add(new Label { Text = "Scroll to see all colors", FontSize = 11, TextColor = Colors.Gray });
return layout;
}
private View CreateContactsCollectionView()
{
var layout = new VerticalStackLayout { Spacing = 10 };
var contacts = new List<ContactItem>
{
new("Alice Johnson", "alice@example.com", "Engineering"),
new("Bob Smith", "bob@example.com", "Marketing"),
new("Carol Williams", "carol@example.com", "Design"),
new("David Brown", "david@example.com", "Sales"),
new("Eva Martinez", "eva@example.com", "Engineering"),
new("Frank Lee", "frank@example.com", "Support"),
new("Grace Kim", "grace@example.com", "HR"),
new("Henry Wilson", "henry@example.com", "Finance")
};
var collectionView = new CollectionView
{
ItemsSource = contacts,
HeightRequest = 200,
SelectionMode = SelectionMode.Single,
BackgroundColor = Colors.White
};
collectionView.SelectionChanged += (s, e) =>
{
if (e.CurrentSelection.Count > 0 && e.CurrentSelection[0] is ContactItem contact)
{
LogEvent($"Contact: {contact.Name} - {contact.Department}");
}
};
layout.Children.Add(collectionView);
// Action buttons
var buttonRow = new HorizontalStackLayout { Spacing = 10 };
var addBtn = new Button { Text = "Add Contact", BackgroundColor = Colors.Green, TextColor = Colors.White };
addBtn.Clicked += (s, e) => LogEvent("Add contact clicked");
var deleteBtn = new Button { Text = "Delete Selected", BackgroundColor = Colors.Red, TextColor = Colors.White };
deleteBtn.Clicked += (s, e) => LogEvent("Delete contact clicked");
buttonRow.Children.Add(addBtn);
buttonRow.Children.Add(deleteBtn);
layout.Children.Add(buttonRow);
return layout;
}
private Frame CreateSection(string title, View content)
{
return new Frame
{
CornerRadius = 8,
Padding = new Thickness(15),
BackgroundColor = Colors.White,
Content = new VerticalStackLayout
{
Spacing = 10,
Children =
{
new Label { Text = title, FontSize = 16, FontAttributes = FontAttributes.Bold },
content
}
}
};
}
private View CreateEventLogPanel()
{
return new Frame
{
BackgroundColor = Color.FromArgb("#F5F5F5"),
Padding = new Thickness(10),
CornerRadius = 0,
Content = new VerticalStackLayout
{
Children =
{
new Label { Text = "Event Log:", FontSize = 12, FontAttributes = FontAttributes.Bold },
new ScrollView
{
HeightRequest = 80,
Content = _eventLog
}
}
}
};
}
private void LogEvent(string message)
{
_eventCount++;
var timestamp = DateTime.Now.ToString("HH:mm:ss");
_eventLog.Text = $"[{timestamp}] {_eventCount}. {message}\n{_eventLog.Text}";
}
}
public record ColorItem(string Name, string Hex)
{
public override string ToString() => Name;
}
public record ContactItem(string Name, string Email, string Department)
{
public override string ToString() => $"{Name} ({Department})";
}

View File

@@ -0,0 +1,261 @@
// PickersPage - Picker, DatePicker, TimePicker Demo
using Microsoft.Maui.Controls;
using Microsoft.Maui.Graphics;
namespace ShellDemo;
public class PickersPage : ContentPage
{
private readonly Label _eventLog;
private int _eventCount = 0;
public PickersPage()
{
Title = "Pickers";
_eventLog = new Label
{
Text = "Events will appear here...",
FontSize = 11,
TextColor = Colors.Gray,
LineBreakMode = LineBreakMode.WordWrap
};
Content = new Grid
{
RowDefinitions =
{
new RowDefinition { Height = new GridLength(1, GridUnitType.Star) },
new RowDefinition { Height = new GridLength(120) }
},
Children =
{
CreateMainContent(),
CreateEventLogPanel()
}
};
Grid.SetRow((View)((Grid)Content).Children[0], 0);
Grid.SetRow((View)((Grid)Content).Children[1], 1);
}
private View CreateMainContent()
{
return new ScrollView
{
Content = new VerticalStackLayout
{
Padding = new Thickness(20),
Spacing = 20,
Children =
{
new Label { Text = "Picker Controls", FontSize = 24, FontAttributes = FontAttributes.Bold },
CreateSection("Picker", CreatePickerDemo()),
CreateSection("DatePicker", CreateDatePickerDemo()),
CreateSection("TimePicker", CreateTimePickerDemo())
}
}
};
}
private View CreatePickerDemo()
{
var layout = new VerticalStackLayout { Spacing = 15 };
// Basic picker
var selectedLabel = new Label { Text = "Selected: (none)", TextColor = Colors.Gray };
var picker1 = new Picker { Title = "Select a fruit" };
picker1.Items.Add("Apple");
picker1.Items.Add("Banana");
picker1.Items.Add("Cherry");
picker1.Items.Add("Date");
picker1.Items.Add("Elderberry");
picker1.Items.Add("Fig");
picker1.Items.Add("Grape");
picker1.SelectedIndexChanged += (s, e) =>
{
if (picker1.SelectedIndex >= 0)
{
var item = picker1.Items[picker1.SelectedIndex];
selectedLabel.Text = $"Selected: {item}";
LogEvent($"Fruit selected: {item}");
}
};
layout.Children.Add(picker1);
layout.Children.Add(selectedLabel);
// Picker with default selection
layout.Children.Add(new Label { Text = "With Default Selection:", FontSize = 12, Margin = new Thickness(0, 10, 0, 0) });
var picker2 = new Picker { Title = "Select a color" };
picker2.Items.Add("Red");
picker2.Items.Add("Green");
picker2.Items.Add("Blue");
picker2.Items.Add("Yellow");
picker2.Items.Add("Purple");
picker2.SelectedIndex = 2; // Blue
picker2.SelectedIndexChanged += (s, e) =>
{
if (picker2.SelectedIndex >= 0)
LogEvent($"Color selected: {picker2.Items[picker2.SelectedIndex]}");
};
layout.Children.Add(picker2);
// Styled picker
layout.Children.Add(new Label { Text = "Styled Picker:", FontSize = 12, Margin = new Thickness(0, 10, 0, 0) });
var picker3 = new Picker
{
Title = "Select size",
TextColor = Colors.DarkBlue,
TitleColor = Colors.Gray
};
picker3.Items.Add("Small");
picker3.Items.Add("Medium");
picker3.Items.Add("Large");
picker3.Items.Add("Extra Large");
picker3.SelectedIndexChanged += (s, e) =>
{
if (picker3.SelectedIndex >= 0)
LogEvent($"Size selected: {picker3.Items[picker3.SelectedIndex]}");
};
layout.Children.Add(picker3);
return layout;
}
private View CreateDatePickerDemo()
{
var layout = new VerticalStackLayout { Spacing = 15 };
// Basic date picker
var dateLabel = new Label { Text = $"Selected: {DateTime.Today:d}" };
var datePicker1 = new DatePicker { Date = DateTime.Today };
datePicker1.DateSelected += (s, e) =>
{
dateLabel.Text = $"Selected: {e.NewDate:d}";
LogEvent($"Date selected: {e.NewDate:d}");
};
layout.Children.Add(datePicker1);
layout.Children.Add(dateLabel);
// Date picker with range
layout.Children.Add(new Label { Text = "With Date Range (this month only):", FontSize = 12, Margin = new Thickness(0, 10, 0, 0) });
var startOfMonth = new DateTime(DateTime.Today.Year, DateTime.Today.Month, 1);
var endOfMonth = startOfMonth.AddMonths(1).AddDays(-1);
var datePicker2 = new DatePicker
{
MinimumDate = startOfMonth,
MaximumDate = endOfMonth,
Date = DateTime.Today
};
datePicker2.DateSelected += (s, e) => LogEvent($"Date (limited): {e.NewDate:d}");
layout.Children.Add(datePicker2);
// Styled date picker
layout.Children.Add(new Label { Text = "Styled DatePicker:", FontSize = 12, Margin = new Thickness(0, 10, 0, 0) });
var datePicker3 = new DatePicker
{
Date = DateTime.Today.AddDays(7),
TextColor = Colors.DarkGreen
};
datePicker3.DateSelected += (s, e) => LogEvent($"Styled date: {e.NewDate:d}");
layout.Children.Add(datePicker3);
return layout;
}
private View CreateTimePickerDemo()
{
var layout = new VerticalStackLayout { Spacing = 15 };
// Basic time picker
var timeLabel = new Label { Text = $"Selected: {DateTime.Now:t}" };
var timePicker1 = new TimePicker { Time = DateTime.Now.TimeOfDay };
timePicker1.PropertyChanged += (s, e) =>
{
if (e.PropertyName == nameof(TimePicker.Time))
{
var time = timePicker1.Time;
timeLabel.Text = $"Selected: {time:hh\\:mm}";
LogEvent($"Time selected: {time:hh\\:mm}");
}
};
layout.Children.Add(timePicker1);
layout.Children.Add(timeLabel);
// Styled time picker
layout.Children.Add(new Label { Text = "Styled TimePicker:", FontSize = 12, Margin = new Thickness(0, 10, 0, 0) });
var timePicker2 = new TimePicker
{
Time = new TimeSpan(14, 30, 0),
TextColor = Colors.DarkBlue
};
timePicker2.PropertyChanged += (s, e) =>
{
if (e.PropertyName == nameof(TimePicker.Time))
LogEvent($"Styled time: {timePicker2.Time:hh\\:mm}");
};
layout.Children.Add(timePicker2);
// Morning alarm example
layout.Children.Add(new Label { Text = "Alarm Time:", FontSize = 12, Margin = new Thickness(0, 10, 0, 0) });
var alarmRow = new HorizontalStackLayout { Spacing = 10 };
var alarmPicker = new TimePicker { Time = new TimeSpan(7, 0, 0) };
var alarmBtn = new Button { Text = "Set Alarm", BackgroundColor = Colors.Orange, TextColor = Colors.White };
alarmBtn.Clicked += (s, e) => LogEvent($"Alarm set for {alarmPicker.Time:hh\\:mm}");
alarmRow.Children.Add(alarmPicker);
alarmRow.Children.Add(alarmBtn);
layout.Children.Add(alarmRow);
return layout;
}
private Frame CreateSection(string title, View content)
{
return new Frame
{
CornerRadius = 8,
Padding = new Thickness(15),
BackgroundColor = Colors.White,
Content = new VerticalStackLayout
{
Spacing = 10,
Children =
{
new Label { Text = title, FontSize = 16, FontAttributes = FontAttributes.Bold },
content
}
}
};
}
private View CreateEventLogPanel()
{
return new Frame
{
BackgroundColor = Color.FromArgb("#F5F5F5"),
Padding = new Thickness(10),
CornerRadius = 0,
Content = new VerticalStackLayout
{
Children =
{
new Label { Text = "Event Log:", FontSize = 12, FontAttributes = FontAttributes.Bold },
new ScrollView
{
HeightRequest = 80,
Content = _eventLog
}
}
}
};
}
private void LogEvent(string message)
{
_eventCount++;
var timestamp = DateTime.Now.ToString("HH:mm:ss");
_eventLog.Text = $"[{timestamp}] {_eventCount}. {message}\n{_eventLog.Text}";
}
}

View File

@@ -0,0 +1,261 @@
// ProgressPage - ProgressBar and ActivityIndicator Demo
using Microsoft.Maui.Controls;
using Microsoft.Maui.Graphics;
namespace ShellDemo;
public class ProgressPage : ContentPage
{
private readonly Label _eventLog;
private int _eventCount = 0;
private ProgressBar? _animatedProgress;
private bool _isAnimating = false;
public ProgressPage()
{
Title = "Progress";
_eventLog = new Label
{
Text = "Events will appear here...",
FontSize = 11,
TextColor = Colors.Gray,
LineBreakMode = LineBreakMode.WordWrap
};
Content = new Grid
{
RowDefinitions =
{
new RowDefinition { Height = new GridLength(1, GridUnitType.Star) },
new RowDefinition { Height = new GridLength(120) }
},
Children =
{
CreateMainContent(),
CreateEventLogPanel()
}
};
Grid.SetRow((View)((Grid)Content).Children[0], 0);
Grid.SetRow((View)((Grid)Content).Children[1], 1);
}
private View CreateMainContent()
{
return new ScrollView
{
Content = new VerticalStackLayout
{
Padding = new Thickness(20),
Spacing = 20,
Children =
{
new Label { Text = "Progress Indicators", FontSize = 24, FontAttributes = FontAttributes.Bold },
CreateSection("ProgressBar", CreateProgressBarDemo()),
CreateSection("ActivityIndicator", CreateActivityIndicatorDemo()),
CreateSection("Interactive Demo", CreateInteractiveDemo())
}
}
};
}
private View CreateProgressBarDemo()
{
var layout = new VerticalStackLayout { Spacing = 15 };
// Various progress values
var values = new[] { 0.0, 0.25, 0.5, 0.75, 1.0 };
foreach (var value in values)
{
var row = new HorizontalStackLayout { Spacing = 10 };
var progress = new ProgressBar { Progress = value, WidthRequest = 200 };
var label = new Label { Text = $"{value * 100:0}%", VerticalOptions = LayoutOptions.Center, WidthRequest = 50 };
row.Children.Add(progress);
row.Children.Add(label);
layout.Children.Add(row);
}
// Colored progress bars
layout.Children.Add(new Label { Text = "Colored Progress Bars:", FontSize = 12, Margin = new Thickness(0, 10, 0, 0) });
var colors = new[] { Colors.Red, Colors.Green, Colors.Blue, Colors.Orange, Colors.Purple };
foreach (var color in colors)
{
var progress = new ProgressBar { Progress = 0.7, ProgressColor = color };
layout.Children.Add(progress);
}
return layout;
}
private View CreateActivityIndicatorDemo()
{
var layout = new VerticalStackLayout { Spacing = 15 };
// Running indicator
var runningRow = new HorizontalStackLayout { Spacing = 15 };
var runningIndicator = new ActivityIndicator { IsRunning = true };
runningRow.Children.Add(runningIndicator);
runningRow.Children.Add(new Label { Text = "Loading...", VerticalOptions = LayoutOptions.Center });
layout.Children.Add(runningRow);
// Toggle indicator
var toggleRow = new HorizontalStackLayout { Spacing = 15 };
var toggleIndicator = new ActivityIndicator { IsRunning = false };
var toggleBtn = new Button { Text = "Start/Stop" };
toggleBtn.Clicked += (s, e) =>
{
toggleIndicator.IsRunning = !toggleIndicator.IsRunning;
LogEvent($"ActivityIndicator: {(toggleIndicator.IsRunning ? "Started" : "Stopped")}");
};
toggleRow.Children.Add(toggleIndicator);
toggleRow.Children.Add(toggleBtn);
layout.Children.Add(toggleRow);
// Colored indicators
layout.Children.Add(new Label { Text = "Colored Indicators:", FontSize = 12, Margin = new Thickness(0, 10, 0, 0) });
var colorRow = new HorizontalStackLayout { Spacing = 20 };
var indicatorColors = new[] { Colors.Red, Colors.Green, Colors.Blue, Colors.Orange };
foreach (var color in indicatorColors)
{
var indicator = new ActivityIndicator { IsRunning = true, Color = color };
colorRow.Children.Add(indicator);
}
layout.Children.Add(colorRow);
return layout;
}
private View CreateInteractiveDemo()
{
var layout = new VerticalStackLayout { Spacing = 15 };
// Slider-controlled progress
var progressLabel = new Label { Text = "Progress: 50%" };
_animatedProgress = new ProgressBar { Progress = 0.5 };
var slider = new Slider { Minimum = 0, Maximum = 100, Value = 50 };
slider.ValueChanged += (s, e) =>
{
var value = e.NewValue / 100.0;
_animatedProgress.Progress = value;
progressLabel.Text = $"Progress: {e.NewValue:0}%";
};
layout.Children.Add(_animatedProgress);
layout.Children.Add(slider);
layout.Children.Add(progressLabel);
// Animated progress buttons
var buttonRow = new HorizontalStackLayout { Spacing = 10, Margin = new Thickness(0, 10, 0, 0) };
var resetBtn = new Button { Text = "Reset", BackgroundColor = Colors.Gray, TextColor = Colors.White };
resetBtn.Clicked += async (s, e) =>
{
_animatedProgress.Progress = 0;
slider.Value = 0;
LogEvent("Progress reset to 0%");
};
var animateBtn = new Button { Text = "Animate to 100%", BackgroundColor = Colors.Blue, TextColor = Colors.White };
animateBtn.Clicked += async (s, e) =>
{
if (_isAnimating) return;
_isAnimating = true;
LogEvent("Animation started");
for (int i = (int)(slider.Value); i <= 100; i += 5)
{
_animatedProgress.Progress = i / 100.0;
slider.Value = i;
await Task.Delay(100);
}
_isAnimating = false;
LogEvent("Animation completed");
};
var simulateBtn = new Button { Text = "Simulate Download", BackgroundColor = Colors.Green, TextColor = Colors.White };
simulateBtn.Clicked += async (s, e) =>
{
if (_isAnimating) return;
_isAnimating = true;
LogEvent("Download simulation started");
_animatedProgress.Progress = 0;
slider.Value = 0;
var random = new Random();
double progress = 0;
while (progress < 1.0)
{
progress += random.NextDouble() * 0.1;
if (progress > 1.0) progress = 1.0;
_animatedProgress.Progress = progress;
slider.Value = progress * 100;
await Task.Delay(200 + random.Next(300));
}
_isAnimating = false;
LogEvent("Download simulation completed");
};
buttonRow.Children.Add(resetBtn);
buttonRow.Children.Add(animateBtn);
buttonRow.Children.Add(simulateBtn);
layout.Children.Add(buttonRow);
return layout;
}
private Frame CreateSection(string title, View content)
{
return new Frame
{
CornerRadius = 8,
Padding = new Thickness(15),
BackgroundColor = Colors.White,
Content = new VerticalStackLayout
{
Spacing = 10,
Children =
{
new Label { Text = title, FontSize = 16, FontAttributes = FontAttributes.Bold },
content
}
}
};
}
private View CreateEventLogPanel()
{
return new Frame
{
BackgroundColor = Color.FromArgb("#F5F5F5"),
Padding = new Thickness(10),
CornerRadius = 0,
Content = new VerticalStackLayout
{
Children =
{
new Label { Text = "Event Log:", FontSize = 12, FontAttributes = FontAttributes.Bold },
new ScrollView
{
HeightRequest = 80,
Content = _eventLog
}
}
}
};
}
private void LogEvent(string message)
{
_eventCount++;
var timestamp = DateTime.Now.ToString("HH:mm:ss");
_eventLog.Text = $"[{timestamp}] {_eventCount}. {message}\n{_eventLog.Text}";
}
}

View File

@@ -0,0 +1,239 @@
// SelectionPage - CheckBox, Switch, Slider Demo
using Microsoft.Maui.Controls;
using Microsoft.Maui.Graphics;
namespace ShellDemo;
public class SelectionPage : ContentPage
{
private readonly Label _eventLog;
private int _eventCount = 0;
public SelectionPage()
{
Title = "Selection Controls";
_eventLog = new Label
{
Text = "Events will appear here...",
FontSize = 11,
TextColor = Colors.Gray,
LineBreakMode = LineBreakMode.WordWrap
};
Content = new Grid
{
RowDefinitions =
{
new RowDefinition { Height = new GridLength(1, GridUnitType.Star) },
new RowDefinition { Height = new GridLength(120) }
},
Children =
{
CreateMainContent(),
CreateEventLogPanel()
}
};
Grid.SetRow((View)((Grid)Content).Children[0], 0);
Grid.SetRow((View)((Grid)Content).Children[1], 1);
}
private View CreateMainContent()
{
return new ScrollView
{
Content = new VerticalStackLayout
{
Padding = new Thickness(20),
Spacing = 20,
Children =
{
new Label { Text = "Selection Controls", FontSize = 24, FontAttributes = FontAttributes.Bold },
CreateSection("CheckBox", CreateCheckBoxDemo()),
CreateSection("Switch", CreateSwitchDemo()),
CreateSection("Slider", CreateSliderDemo())
}
}
};
}
private View CreateCheckBoxDemo()
{
var layout = new VerticalStackLayout { Spacing = 15 };
// Basic checkboxes
var basicRow = new HorizontalStackLayout { Spacing = 20 };
var cb1 = new CheckBox { IsChecked = false };
cb1.CheckedChanged += (s, e) => LogEvent($"Checkbox 1: {(e.Value ? "Checked" : "Unchecked")}");
basicRow.Children.Add(cb1);
basicRow.Children.Add(new Label { Text = "Option 1", VerticalOptions = LayoutOptions.Center });
var cb2 = new CheckBox { IsChecked = true };
cb2.CheckedChanged += (s, e) => LogEvent($"Checkbox 2: {(e.Value ? "Checked" : "Unchecked")}");
basicRow.Children.Add(cb2);
basicRow.Children.Add(new Label { Text = "Option 2 (default checked)", VerticalOptions = LayoutOptions.Center });
layout.Children.Add(basicRow);
// Colored checkboxes
var colorRow = new HorizontalStackLayout { Spacing = 20 };
var colors = new[] { Colors.Red, Colors.Green, Colors.Blue, Colors.Purple };
foreach (var color in colors)
{
var cb = new CheckBox { Color = color, IsChecked = true };
cb.CheckedChanged += (s, e) => LogEvent($"{color} checkbox: {(e.Value ? "Checked" : "Unchecked")}");
colorRow.Children.Add(cb);
}
layout.Children.Add(new Label { Text = "Colored Checkboxes:", FontSize = 12 });
layout.Children.Add(colorRow);
// Disabled checkbox
var disabledRow = new HorizontalStackLayout { Spacing = 10 };
var disabledCb = new CheckBox { IsChecked = true, IsEnabled = false };
disabledRow.Children.Add(disabledCb);
disabledRow.Children.Add(new Label { Text = "Disabled (checked)", VerticalOptions = LayoutOptions.Center, TextColor = Colors.Gray });
layout.Children.Add(disabledRow);
return layout;
}
private View CreateSwitchDemo()
{
var layout = new VerticalStackLayout { Spacing = 15 };
// Basic switch
var basicRow = new HorizontalStackLayout { Spacing = 15 };
var statusLabel = new Label { Text = "Off", VerticalOptions = LayoutOptions.Center, WidthRequest = 50 };
var sw1 = new Switch { IsToggled = false };
sw1.Toggled += (s, e) =>
{
statusLabel.Text = e.Value ? "On" : "Off";
LogEvent($"Switch toggled: {(e.Value ? "ON" : "OFF")}");
};
basicRow.Children.Add(sw1);
basicRow.Children.Add(statusLabel);
layout.Children.Add(basicRow);
// Colored switches
var colorRow = new HorizontalStackLayout { Spacing = 20 };
var switchColors = new[] { Colors.Green, Colors.Orange, Colors.Purple };
foreach (var color in switchColors)
{
var sw = new Switch { IsToggled = true, OnColor = color };
sw.Toggled += (s, e) => LogEvent($"{color} switch: {(e.Value ? "ON" : "OFF")}");
colorRow.Children.Add(sw);
}
layout.Children.Add(new Label { Text = "Colored Switches:", FontSize = 12 });
layout.Children.Add(colorRow);
// Disabled switch
var disabledRow = new HorizontalStackLayout { Spacing = 10 };
var disabledSw = new Switch { IsToggled = true, IsEnabled = false };
disabledRow.Children.Add(disabledSw);
disabledRow.Children.Add(new Label { Text = "Disabled (on)", VerticalOptions = LayoutOptions.Center, TextColor = Colors.Gray });
layout.Children.Add(disabledRow);
return layout;
}
private View CreateSliderDemo()
{
var layout = new VerticalStackLayout { Spacing = 15 };
// Basic slider
var valueLabel = new Label { Text = "Value: 50" };
var slider1 = new Slider { Minimum = 0, Maximum = 100, Value = 50 };
slider1.ValueChanged += (s, e) =>
{
valueLabel.Text = $"Value: {(int)e.NewValue}";
LogEvent($"Slider value: {(int)e.NewValue}");
};
layout.Children.Add(slider1);
layout.Children.Add(valueLabel);
// Slider with custom range
layout.Children.Add(new Label { Text = "Temperature (0-40°C):", FontSize = 12, Margin = new Thickness(0, 10, 0, 0) });
var tempLabel = new Label { Text = "20°C" };
var tempSlider = new Slider { Minimum = 0, Maximum = 40, Value = 20 };
tempSlider.ValueChanged += (s, e) =>
{
tempLabel.Text = $"{(int)e.NewValue}°C";
LogEvent($"Temperature: {(int)e.NewValue}°C");
};
layout.Children.Add(tempSlider);
layout.Children.Add(tempLabel);
// Colored slider
layout.Children.Add(new Label { Text = "Colored Slider:", FontSize = 12, Margin = new Thickness(0, 10, 0, 0) });
var colorSlider = new Slider
{
Minimum = 0,
Maximum = 100,
Value = 75,
MinimumTrackColor = Colors.Green,
MaximumTrackColor = Colors.LightGray,
ThumbColor = Colors.DarkGreen
};
colorSlider.ValueChanged += (s, e) => LogEvent($"Colored slider: {(int)e.NewValue}");
layout.Children.Add(colorSlider);
// Disabled slider
layout.Children.Add(new Label { Text = "Disabled Slider:", FontSize = 12, Margin = new Thickness(0, 10, 0, 0) });
var disabledSlider = new Slider { Minimum = 0, Maximum = 100, Value = 30, IsEnabled = false };
layout.Children.Add(disabledSlider);
return layout;
}
private Frame CreateSection(string title, View content)
{
return new Frame
{
CornerRadius = 8,
Padding = new Thickness(15),
BackgroundColor = Colors.White,
Content = new VerticalStackLayout
{
Spacing = 10,
Children =
{
new Label { Text = title, FontSize = 16, FontAttributes = FontAttributes.Bold },
content
}
}
};
}
private View CreateEventLogPanel()
{
return new Frame
{
BackgroundColor = Color.FromArgb("#F5F5F5"),
Padding = new Thickness(10),
CornerRadius = 0,
Content = new VerticalStackLayout
{
Children =
{
new Label { Text = "Event Log:", FontSize = 12, FontAttributes = FontAttributes.Bold },
new ScrollView
{
HeightRequest = 80,
Content = _eventLog
}
}
}
};
}
private void LogEvent(string message)
{
_eventCount++;
var timestamp = DateTime.Now.ToString("HH:mm:ss");
_eventLog.Text = $"[{timestamp}] {_eventCount}. {message}\n{_eventLog.Text}";
}
}

View File

@@ -0,0 +1,166 @@
// TextInputPage - Demonstrates text input controls
using Microsoft.Maui.Controls;
using Microsoft.Maui.Graphics;
namespace ShellDemo;
public class TextInputPage : ContentPage
{
private Label _entryOutput;
private Label _searchOutput;
private Label _editorOutput;
public TextInputPage()
{
Title = "Text Input";
_entryOutput = new Label { TextColor = Colors.Gray, FontSize = 12 };
_searchOutput = new Label { TextColor = Colors.Gray, FontSize = 12 };
_editorOutput = new Label { TextColor = Colors.Gray, FontSize = 12 };
Content = new ScrollView
{
Content = new VerticalStackLayout
{
Padding = new Thickness(20),
Spacing = 15,
Children =
{
new Label
{
Text = "Text Input Controls",
FontSize = 24,
FontAttributes = FontAttributes.Bold
},
new Label
{
Text = "Click on any field and start typing. All keyboard input is handled by the framework.",
FontSize = 14,
TextColor = Colors.Gray
},
// Entry Section
new BoxView { HeightRequest = 1, Color = Colors.LightGray },
new Label { Text = "Entry (Single Line)", FontSize = 18, FontAttributes = FontAttributes.Bold },
CreateEntry("Enter your name...", e => _entryOutput.Text = $"You typed: {e.Text}"),
_entryOutput,
CreateEntry("Enter your email...", null, Keyboard.Email),
new Label { Text = "Email keyboard type", FontSize = 12, TextColor = Colors.Gray },
CreatePasswordEntry("Enter password..."),
new Label { Text = "Password field (text hidden)", FontSize = 12, TextColor = Colors.Gray },
// SearchBar Section
new BoxView { HeightRequest = 1, Color = Colors.LightGray },
new Label { Text = "SearchBar", FontSize = 18, FontAttributes = FontAttributes.Bold },
CreateSearchBar(),
_searchOutput,
// Editor Section
new BoxView { HeightRequest = 1, Color = Colors.LightGray },
new Label { Text = "Editor (Multi-line)", FontSize = 18, FontAttributes = FontAttributes.Bold },
CreateEditor(),
_editorOutput,
// Instructions
new BoxView { HeightRequest = 1, Color = Colors.LightGray },
new Frame
{
BackgroundColor = Color.FromArgb("#E3F2FD"),
CornerRadius = 8,
Padding = new Thickness(15),
Content = new VerticalStackLayout
{
Spacing = 5,
Children =
{
new Label
{
Text = "Keyboard Shortcuts",
FontAttributes = FontAttributes.Bold
},
new Label { Text = "Ctrl+A: Select all" },
new Label { Text = "Ctrl+C: Copy" },
new Label { Text = "Ctrl+V: Paste" },
new Label { Text = "Ctrl+X: Cut" },
new Label { Text = "Home/End: Move to start/end" },
new Label { Text = "Shift+Arrow: Select text" }
}
}
}
}
}
};
}
private Entry CreateEntry(string placeholder, Action<Entry>? onTextChanged, Keyboard? keyboard = null)
{
var entry = new Entry
{
Placeholder = placeholder,
FontSize = 14
};
if (keyboard != null)
{
entry.Keyboard = keyboard;
}
if (onTextChanged != null)
{
entry.TextChanged += (s, e) => onTextChanged(entry);
}
return entry;
}
private Entry CreatePasswordEntry(string placeholder)
{
return new Entry
{
Placeholder = placeholder,
FontSize = 14,
IsPassword = true
};
}
private SearchBar CreateSearchBar()
{
var searchBar = new SearchBar
{
Placeholder = "Search for items..."
};
searchBar.TextChanged += (s, e) =>
{
_searchOutput.Text = $"Searching: {e.NewTextValue}";
};
searchBar.SearchButtonPressed += (s, e) =>
{
_searchOutput.Text = $"Search submitted: {searchBar.Text}";
};
return searchBar;
}
private Editor CreateEditor()
{
var editor = new Editor
{
Placeholder = "Enter multiple lines of text here...\nPress Enter to create new lines.",
HeightRequest = 120,
FontSize = 14
};
editor.TextChanged += (s, e) =>
{
var lineCount = string.IsNullOrEmpty(e.NewTextValue) ? 0 : e.NewTextValue.Split('\n').Length;
_editorOutput.Text = $"Lines: {lineCount}, Characters: {e.NewTextValue?.Length ?? 0}";
};
return editor;
}
}

View File

@@ -0,0 +1,19 @@
// Platforms/Linux/Program.cs - Linux platform entry point
// Same pattern as Android's MainActivity or iOS's AppDelegate
using Microsoft.Maui.Platform.Linux;
using Microsoft.Maui.Platform.Linux.Hosting;
namespace ShellDemo;
class Program
{
static void Main(string[] args)
{
// Create the shared MAUI app
var app = MauiProgram.CreateMauiApp();
// Run on Linux platform
LinuxApplication.Run(app, args);
}
}

View File

@@ -0,0 +1,157 @@
# ShellDemo Sample
A comprehensive control showcase application demonstrating all OpenMaui Linux controls with Shell navigation and flyout menu.
## Features
- **Shell Navigation** - Flyout menu with multiple pages
- **Route-Based Navigation** - Push navigation with registered routes
- **All Core Controls** - Button, Entry, Editor, CheckBox, Switch, Slider, Picker, etc.
- **CollectionView** - Lists with selection and data binding
- **Progress Indicators** - ProgressBar and ActivityIndicator with animations
- **Grid Layouts** - Complex multi-column/row layouts
- **Event Logging** - Real-time event feedback panel
## Pages
| Page | Controls Demonstrated |
|------|----------------------|
| **Home** | Welcome screen, navigation overview |
| **Buttons** | Button styles, colors, states, click/press/release events |
| **Text Input** | Entry, Editor, SearchBar, password fields, keyboard types |
| **Selection** | CheckBox, Switch, Slider with colors and states |
| **Pickers** | Picker, DatePicker, TimePicker with styling |
| **Lists** | CollectionView with selection, custom items |
| **Progress** | ProgressBar, ActivityIndicator, animated demos |
| **Grids** | Grid layouts with row/column definitions |
| **About** | App information |
## Architecture
```
ShellDemo/
├── App.cs # AppShell definition with flyout
├── Program.cs # Linux platform bootstrap
├── MauiProgram.cs # MAUI app builder
└── Pages/
├── HomePage.cs # Welcome page
├── ButtonsPage.cs # Button demonstrations
├── TextInputPage.cs # Entry, Editor, SearchBar
├── SelectionPage.cs # CheckBox, Switch, Slider
├── PickersPage.cs # Picker, DatePicker, TimePicker
├── ListsPage.cs # CollectionView demos
├── ProgressPage.cs # ProgressBar, ActivityIndicator
├── GridsPage.cs # Grid layout demos
├── DetailPage.cs # Push navigation target
└── AboutPage.cs # About information
```
## Shell Configuration
```csharp
public class AppShell : Shell
{
public AppShell()
{
FlyoutBehavior = FlyoutBehavior.Flyout;
Title = "OpenMaui Controls Demo";
// Register routes for push navigation
Routing.RegisterRoute("detail", typeof(DetailPage));
// Add flyout items
Items.Add(CreateFlyoutItem("Home", typeof(HomePage)));
Items.Add(CreateFlyoutItem("Buttons", typeof(ButtonsPage)));
// ...more items
}
}
```
## Control Demonstrations
### Buttons Page
- Default, styled, and transparent buttons
- Color variations (Primary, Success, Warning, Danger)
- Enabled/disabled state toggling
- Wide, tall, and round button shapes
- Pressed, clicked, released event handling
### Text Input Page
- Entry with placeholder and text change events
- Password entry with hidden text
- Email keyboard type
- SearchBar with search button
- Multi-line Editor
- Keyboard shortcuts guide
### Selection Page
- CheckBox with colors and disabled state
- Switch with OnColor customization
- Slider with min/max range and track colors
### Pickers Page
- Picker with items and selection events
- DatePicker with date range limits
- TimePicker with time selection
- Styled pickers with custom colors
### Lists Page
- CollectionView with string items
- CollectionView with custom data types (ColorItem, ContactItem)
- Selection handling and event feedback
### Progress Page
- ProgressBar at various percentages
- Colored progress bars
- ActivityIndicator running/stopped states
- Colored activity indicators
- Interactive slider-controlled progress
- Animated progress simulation
## Building and Running
```bash
# From the maui-linux-push directory
cd samples/ShellDemo
dotnet publish -c Release -r linux-arm64
# Run on Linux
./bin/Release/net9.0/linux-arm64/publish/ShellDemo
```
## Event Logging
Each page features an event log panel that displays control interactions in real-time:
```
[14:32:15] 3. Button clicked: Primary
[14:32:12] 2. Slider value: 75
[14:32:08] 1. CheckBox: Checked
```
## Controls Reference
| Control | Properties Demonstrated |
|---------|------------------------|
| Button | Text, BackgroundColor, TextColor, CornerRadius, IsEnabled, WidthRequest, HeightRequest |
| Entry | Placeholder, Text, IsPassword, Keyboard, FontSize |
| Editor | Placeholder, Text, HeightRequest |
| SearchBar | Placeholder, Text, SearchButtonPressed |
| CheckBox | IsChecked, Color, IsEnabled |
| Switch | IsToggled, OnColor, IsEnabled |
| Slider | Minimum, Maximum, Value, MinimumTrackColor, MaximumTrackColor, ThumbColor |
| Picker | Title, Items, SelectedIndex, TextColor, TitleColor |
| DatePicker | Date, MinimumDate, MaximumDate, TextColor |
| TimePicker | Time, TextColor |
| CollectionView | ItemsSource, SelectionMode, SelectionChanged, HeightRequest |
| ProgressBar | Progress, ProgressColor |
| ActivityIndicator | IsRunning, Color |
| Label | Text, FontSize, FontAttributes, TextColor |
| Frame | CornerRadius, Padding, BackgroundColor |
| Grid | RowDefinitions, ColumnDefinitions, RowSpacing, ColumnSpacing |
| StackLayout | Spacing, Padding, Orientation |
| ScrollView | Content scrolling |
## License
MIT License - See repository root for details.

View File

@@ -0,0 +1,15 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>net9.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../OpenMaui.Controls.Linux.csproj" />
</ItemGroup>
</Project>

View File

@@ -0,0 +1,283 @@
// 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;
using Microsoft.Maui.Controls;
using Microsoft.Maui.Hosting;
using Microsoft.Maui.Platform.Linux;
using Microsoft.Maui.Platform.Linux.Hosting;
namespace WebViewDemo;
public static class MauiProgram
{
public static MauiApp CreateMauiApp()
{
var builder = MauiApp.CreateBuilder();
builder.UseMauiApp<App>();
builder.UseLinux();
return builder.Build();
}
}
public static class Program
{
public static void Main(string[] args)
{
Console.WriteLine("[Program] Starting WebView Demo");
var app = MauiProgram.CreateMauiApp();
LinuxApplication.Run(app, args);
}
}
public class App : Application
{
public App()
{
MainPage = new NavigationPage(new WebViewPage())
{
Title = "WebView Demo"
};
}
}
public class WebViewPage : ContentPage
{
private readonly WebView _webView;
private readonly Entry _urlEntry;
private readonly Label _statusLabel;
public WebViewPage()
{
Title = "WebView Demo";
_webView = new WebView
{
HeightRequest = 400,
VerticalOptions = LayoutOptions.Fill,
HorizontalOptions = LayoutOptions.Fill,
Source = new UrlWebViewSource { Url = "https://dotnet.microsoft.com" }
};
_webView.Navigating += OnNavigating;
_webView.Navigated += OnNavigated;
_urlEntry = new Entry
{
Placeholder = "Enter URL...",
Text = "https://dotnet.microsoft.com",
HorizontalOptions = LayoutOptions.Fill
};
_urlEntry.Completed += OnUrlSubmitted;
_statusLabel = new Label
{
Text = "Ready",
TextColor = Colors.Gray,
FontSize = 12
};
var goButton = new Button
{
Text = "Go",
WidthRequest = 60
};
goButton.Clicked += (s, e) => Navigate();
var backButton = new Button
{
Text = "Back",
WidthRequest = 60
};
backButton.Clicked += (s, e) => _webView.GoBack();
var forwardButton = new Button
{
Text = "Forward",
WidthRequest = 80
};
forwardButton.Clicked += (s, e) => _webView.GoForward();
var reloadButton = new Button
{
Text = "Reload",
WidthRequest = 70
};
reloadButton.Clicked += (s, e) => _webView.Reload();
var loadHtmlButton = new Button
{
Text = "Load HTML",
WidthRequest = 100
};
loadHtmlButton.Clicked += OnLoadHtmlClicked;
var evalJsButton = new Button
{
Text = "Run JS",
WidthRequest = 80
};
evalJsButton.Clicked += OnEvalJsClicked;
// Navigation bar
var navBar = new HorizontalStackLayout
{
Spacing = 5,
Children = { backButton, forwardButton, reloadButton }
};
// URL bar
var urlBar = new HorizontalStackLayout
{
Spacing = 5,
Children = { _urlEntry, goButton }
};
// Action buttons
var actionBar = new HorizontalStackLayout
{
Spacing = 5,
Children = { loadHtmlButton, evalJsButton }
};
Content = new VerticalStackLayout
{
Padding = 10,
Spacing = 10,
Children =
{
new Label { Text = "WebView Demo - WebKitGTK", FontSize = 20, FontAttributes = FontAttributes.Bold },
navBar,
urlBar,
_webView,
actionBar,
_statusLabel
}
};
}
private void Navigate()
{
var url = _urlEntry.Text?.Trim();
if (string.IsNullOrEmpty(url))
return;
// Add https:// if not present
if (!url.StartsWith("http://") && !url.StartsWith("https://"))
url = "https://" + url;
_webView.Source = new UrlWebViewSource { Url = url };
_urlEntry.Text = url;
}
private void OnUrlSubmitted(object? sender, EventArgs e)
{
Navigate();
}
private void OnNavigating(object? sender, WebNavigatingEventArgs e)
{
_statusLabel.Text = $"Loading: {e.Url}";
Console.WriteLine($"[WebViewPage] Navigating to: {e.Url}");
}
private void OnNavigated(object? sender, WebNavigatedEventArgs e)
{
_statusLabel.Text = e.Result == WebNavigationResult.Success
? $"Loaded: {e.Url}"
: $"Failed: {e.Result}";
_urlEntry.Text = e.Url;
Console.WriteLine($"[WebViewPage] Navigated: {e.Result} - {e.Url}");
}
private void OnLoadHtmlClicked(object? sender, EventArgs e)
{
var html = @"
<!DOCTYPE html>
<html>
<head>
<title>OpenMaui WebView</title>
<style>
body {
font-family: 'Segoe UI', Arial, sans-serif;
margin: 40px;
background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
color: white;
min-height: 100vh;
}
h1 {
font-size: 2.5em;
margin-bottom: 20px;
}
p {
font-size: 1.2em;
line-height: 1.6;
}
.feature-list {
background: rgba(255,255,255,0.1);
padding: 20px;
border-radius: 10px;
margin-top: 20px;
}
li {
margin: 10px 0;
font-size: 1.1em;
}
button {
background: #4CAF50;
color: white;
border: none;
padding: 15px 30px;
font-size: 1.1em;
border-radius: 5px;
cursor: pointer;
margin-top: 20px;
}
button:hover {
background: #45a049;
}
</style>
</head>
<body>
<h1>Hello from OpenMaui Linux!</h1>
<p>This HTML content is rendered by WebKitGTK inside your .NET MAUI application.</p>
<div class='feature-list'>
<h2>WebView Features:</h2>
<ul>
<li>Full HTML5 support</li>
<li>CSS3 animations and transitions</li>
<li>JavaScript execution</li>
<li>Navigation history (back/forward)</li>
<li>WebGL and canvas support</li>
</ul>
</div>
<button onclick=""alert('Hello from JavaScript!')"">Click Me!</button>
<p style='margin-top: 30px; opacity: 0.8;'>
Powered by WebKitGTK - the same engine used by GNOME Web (Epiphany)
</p>
</body>
</html>";
_webView.Source = new HtmlWebViewSource { Html = html };
_statusLabel.Text = "Loaded custom HTML";
}
private async void OnEvalJsClicked(object? sender, EventArgs e)
{
try
{
var result = await _webView.EvaluateJavaScriptAsync("document.title");
_statusLabel.Text = $"JS Result: {result ?? "(null)"}";
Console.WriteLine($"[WebViewPage] JS Eval result: {result}");
}
catch (Exception ex)
{
_statusLabel.Text = $"JS Error: {ex.Message}";
}
}
}

View File

@@ -0,0 +1,18 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>net9.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
<RootNamespace>WebViewDemo</RootNamespace>
<RuntimeIdentifier>linux-arm64</RuntimeIdentifier>
<SelfContained>true</SelfContained>
<PublishSingleFile>false</PublishSingleFile>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="../../OpenMaui.Controls.Linux.csproj" />
</ItemGroup>
</Project>