MewUI Documentation

The Aprillz.MewUI.Svg extension provides SVG rendering for MewUI via the IGraphicsContext.

Key features:

• Pure managed: Does not depend on System.Drawing.
• Backend Agnostic: Built on SVG.NET with a MewUI rendering backend, making it compatible with all MewUI backends (Direct2D, GDI, MewVG/OpenGL).
• AOT/Trim Friendly: Designed to be compatible with NativeAOT and trimming.

Dependencies:

• Aprillz.MewUI
• ExCSS
• Bundles SVG.NET (Ms-PL license)

Aprillz.MewUI.Analyzers provides Roslyn analyzers and refactorings specifically designed for MewUI fluent markup. It is distributed as a NuGet analyzer (analyzers/dotnet/cs), making it compatible with Visual Studio, VS Code (C# Dev Kit), Rider, and CI environments.

Key Characteristics:

• Build-time only: The analyzers do not add any code to your runtime or NativeAOT output.
• Automatic Discovery: The analyzer uses the existing extension methods in your project as the source of truth for fluent setters.
• Status: Early experimental version (as of 2026-06-15). Diagnostic IDs and behaviors may change.

Supported Diagnostic IDs:

• MEW1101: Convert object initializer to fluent chain.
• MEW1102: Fluent chain expand / collapse.
• MEW1103: Merge statements into a fluent chain.
• MEW1104: Property assignment to fluent call.

The Skia integration is split into several packages to allow for modularity and platform-specific optimizations:

• Aprillz.MewUI.Skia: The core package containing SkiaCanvasView, the ISkiaInteropProvider registry, and the default CPU upload fallback.
• Aprillz.MewUI.Skia.Interop.*: Specialized packages providing zero-copy GPU bridges for specific backends.
• Aprillz.MewUI.Skia.{Windows,Linux,MacOS,All}: Metapackages that bundle the core package with all relevant interop packages for a specific platform.

Animations in MewUI do not exist in a separate layer; instead, they use a wrapper mechanism.

When an animation starts, the property value is wrapped in an AnimatedEntry which preserves the original base value and its source. Every frame, the interpolated value is updated via an internal SetAnimatedValue call.

Key Behaviors:

• Completion: When the animation finishes, ClearAnimatedValue is called, restoring the preserved base value and source.
• Interruption: If SetValue is called on the property from any source while an animation is running, the animation is immediately stopped and the new value is stored.
• Priority: From a value resolution perspective, Animated values have a lower priority than Local values, but a higher priority than Trigger or Style values.

In MewUI, Element.Bounds is expressed in window-absolute coordinates, not relative to the parent.

When building custom panels, you must arrange children by offsetting from your own absolute Bounds. For example: child.Arrange(new Rect(Bounds.X + offsetX, Bounds.Y + offsetY, ...)).

Accessing Parent-Relative Coordinates: If you need coordinates relative to a parent, do not use Bounds. Instead:

• Use RenderSize to get the element's size without its origin.
• Use TranslatePoint, TranslateRect, TransformToAncestor, or TransformToDescendant to convert between different coordinate spaces.

// Incorrect: assuming Bounds is local
// child.Arrange(new Rect(0, 0, width, height)); 

// Correct: offsetting from window-absolute Bounds
child.Arrange(new Rect(Bounds.X + offsetX, Bounds.Y + offsetY, childWidth, childHeight));

The ArrangeContent phase is where you determine the final positions of child elements within the space allocated to the control.

Key Concepts

• Child Rects: For controls with children, use this phase to calculate child rectangles and call Arrange on them.
• Bounds vs DesiredSize: You must assume that the DesiredSize calculated during Measure may differ from the actual Bounds assigned to the control. Always layout children based on the actual Bounds received.

MewUI's C# Markup is a Fluent API that allows you to declare UI using pure C# code instead of XAML. It is designed for high performance and modern deployment scenarios:

• Native AOT Compatible: Everything is determined at compile time without using Reflection.
• Type Safety: Errors are caught by the compiler.
• IntelliSense: Full IDE auto-completion support.
• Code Reusability: You can extract UI components into standard C# methods.

All extension methods return this, enabling a method-chaining pattern.

new Button()
    .Content("Click Me")
    .Width(100)
    .OnClick(() => Console.WriteLine("Clicked!"))

You can control the enabled/disabled state of a Button based on a condition using OnCanClick. This is similar to the WPF ICommand.CanExecute pattern.

Automatic Re-evaluation: CanClick is automatically re-evaluated during:

• Focus changes
• MouseUp events
• KeyUp events

Manual Re-evaluation: If your state changes outside of these events (e.g., in a background task or custom logic), call window.RequerySuggested() to force the UI to re-evaluate the CanClick condition.

var text = new ObservableValue<string>("");

new TextBox()
    .BindText(text)
    .OnTextChanged(_ => window.RequerySuggested()),

new Button()
    .Content("Submit")
    .OnCanClick(() => !string.IsNullOrWhiteSpace(text.Value))
    .OnClick(() => Submit(text.Value))