Pysar.Xaml
0.1.41
See the version list below for details.
dotnet add package Pysar.Xaml --version 0.1.41
NuGet\Install-Package Pysar.Xaml -Version 0.1.41
<PackageReference Include="Pysar.Xaml" Version="0.1.41" />
<PackageVersion Include="Pysar.Xaml" Version="0.1.41" />
<PackageReference Include="Pysar.Xaml" />
paket add Pysar.Xaml --version 0.1.41
#r "nuget: Pysar.Xaml, 0.1.41"
#:package Pysar.Xaml@0.1.41
#addin nuget:?package=Pysar.Xaml&version=0.1.41
#tool nuget:?package=Pysar.Xaml&version=0.1.41
Pysar.Xaml
Declarative report markup for Pysar, a cross-platform report
engine for .NET: this package contains the runtime .rxaml loader and the code-behind source
generator. It depends on the core Pysar package, which carries the element tree, data binding and
the SkiaSharp rendering and PDF engine.
.rxaml is Pysar's markup dialect: an XML document that describes a report the same way the fluent
builder does, using the same elements (Grid, StackPanel, Frame, Text, Image, Repeater)
and the same bands. It is the better fit for a report with a fixed shape — an invoice, a statement, a
certificate — because the layout stays readable as a tree instead of a chain of method calls, and it
is what makes a report editable by someone who is not writing C#: a template stored in a database, or
edited through the design-time preview in Rider and VS Code.
<Report xmlns="https://mriyalab.com/pysar" x:DataType="local:Invoice">
<PageFormat Size="A4" Margin="30" />
<ReportHeaderBand>
<Text Content="{Binding Company.Name}" FontSize="18" FontStyle="Bold" />
</ReportHeaderBand>
<DetailBand DataSource="{Binding Items}">
<DetailBand.DetailHeader>
<Text Content="Product" FontStyle="Bold" />
</DetailBand.DetailHeader>
<Grid ColumnDefinitions="*, 80, 80">
<Text Grid.Column="0" Content="{Binding Product}" />
<Text Grid.Column="1" Content="{Binding Quantity}" />
<Text Grid.Column="2" Content="{Binding Total, StringFormat='{0:C}'}">
<Text.Triggers>
<DataTrigger Binding="{Binding Total}" CompareType="GreaterThan" Value="1000">
<Setter Member="FontColor" Value="Chocolate" />
</DataTrigger>
</Text.Triggers>
</Text>
</Grid>
</DetailBand>
</Report>
An .rxaml report supports the same binding system as the object model: {Binding Path} against the
element's data context, string formats, value converters, and DataTrigger for conditional
formatting. A DataSource on DetailBand (or any Repeater) puts its children in a per-item scope
over the bound collection, with an optional DetailHeader and DetailFooter that stay in the outer
scope.
Loading at runtime
Reports can be loaded at runtime, which is what a template stored in a database or edited by a user needs:
using Pysar.Xaml;
var report = ReportXaml.Load("""
<Report xmlns="https://mriyalab.com/pysar">
<PageFormat Size="A4" Margin="30" />
<DetailBand>
<Text Content="Hello from XAML" />
</DetailBand>
</Report>
""");
report.Build();
Code-behind source generator
For application projects, the source generator uses the standard x:Class directive to provide
generated InitializeComponent(), strongly typed x:Name fields, and compiled object construction.
The generator ships inside this package as an analyzer and is wired up automatically through
build/Pysar.Xaml.props — no separate analyzer reference is needed. Every .rxaml file in the
project is picked up automatically; set <EnableDefaultReportItems>false</EnableDefaultReportItems>
to list them yourself. Resources, styles, and triggers currently use the runtime-loader fallback.
Compile-time binding validation
Any element accepts the MAUI-style directive x:DataType="local:Invoice" to declare the
data-context type of a scope. The hint is design-time only — it is ignored when the report is
loaded — and is inherited by child elements until another element declares its own;
x:DataType="" clears it for that subtree. The source generator validates {Binding ...} paths —
and DataTrigger.Binding — against the hint at build time (PQX010 error for an unknown member,
PQX011 warning for a type it cannot resolve). Where the scope cannot be known, nothing is reported
rather than guessed: styles and resource dictionaries are reused across scopes, so their bindings are
never validated. The XAML designer idiom d:DataContext="{d:DesignInstance Type=local:Invoice}" is
an accepted alternative spelling of the same hint, used when no x:DataType is present on the
element.
Documentation
License
MIT — see LICENSE.
| Product | Versions Compatible and additional computed target framework versions. |
|---|---|
| .NET | net10.0 is compatible. net10.0-android was computed. net10.0-browser was computed. net10.0-ios was computed. net10.0-maccatalyst was computed. net10.0-macos was computed. net10.0-tvos was computed. net10.0-windows was computed. |
-
net10.0
- HarfBuzzSharp (>= 14.2.1.1)
- HarfBuzzSharp.NativeAssets.Linux (>= 14.2.1.1)
- HarfBuzzSharp.NativeAssets.macOS (>= 14.2.1.1)
- HarfBuzzSharp.NativeAssets.Win32 (>= 14.2.1.1)
- Microsoft.Extensions.DependencyInjection.Abstractions (>= 10.0.11)
- Pysar (>= 0.1.41)
- SkiaSharp (>= 4.151.2)
- SkiaSharp.NativeAssets.Linux (>= 4.151.2)
- SkiaSharp.NativeAssets.macOS (>= 4.151.2)
- SkiaSharp.NativeAssets.Win32 (>= 4.151.2)
- Svg.Skia (>= 5.2.3)
NuGet packages
This package is not used by any NuGet packages.
GitHub repositories
This package is not used by any popular GitHub repositories.
## Highlights
### Uno integration: a real entry point
Registering Pysar in an Uno application is now a single call on `Application`, and it works the same
way from every head (WebAssembly, Desktop, Android, iOS, WinAppSDK) — `OnLaunched` is the one place
they all run through.
```csharp
protected override void OnLaunched(LaunchActivatedEventArgs args)
{
this.UsePysar(typeof(App).Assembly, pysar => pysar
.AddFont("Fonts/Ubuntu-Regular.ttf", "Ubuntu")
.AddFont("Fonts/Ubuntu-Bold.ttf", "Ubuntu", FontStyle.Bold));
}
```
- `ApplicationExtensions.UsePysar(...)` and `UsePysarAsync(...)` — the latter preloads
`ms-appx:///` assets for applications that ship them as `Content` rather than `EmbeddedResource`.
- `assetAssembly` is required: on the WebAssembly head the entry assembly is the head project, not
the application project the assets are packaged into.
- Registration moved into `UnoRegistration`; `PysarUno` now exposes `PlatformHandler` /
`ExportService` and resets the export service on re-registration.
### Ctrl+wheel and trackpad pinch zoom the report, not the page (browser head)
`ReportView` has always zoomed on Ctrl+wheel and marked the event handled, but on a browser head
that changed nothing visible: "handled" is a managed routing flag, while page zoom is a DOM default
action that only `preventDefault` on a non-passive listener stops. The reader got a scaled page and
a report that never moved — and the trackpad pinch went with it, since Chrome and Safari deliver it
as a wheel event with `ctrlKey` set.
`UsePysar` now installs a small embedded script, imported from a data URL, so a consuming
application adds one call and no files. Opt out with `suppressBrowserZoom: false` to keep the
browser's own zoom as an accessibility affordance.
Suppression covers the whole Uno canvas: Uno draws the entire application into a single canvas, so
the DOM cannot tell the report from the toolbar beside it. Anything on the page outside that canvas
keeps the browser's zoom.
### Measure probe caching
New `MeasureContext` and `LayoutEngine.ProbeSizeAsync` cache probe measurements, and
`GridLayoutMeasurer` / `StackLayoutMeasurer` now measure through probes instead of re-measuring the
same subtree repeatedly — a large drop in repeat measures on nested layouts.
### A readable diagnostic for the SkiaSharp native/managed split on WebAssembly
An Uno browser head pulls `SkiaSharp.NativeAssets.WebAssembly` through
`Uno.WinUI.Runtime.Skia.WebAssembly.Browser`, which asks for the 3.119 line, while Pysar renders
through 4.151. NuGet resolves one managed SkiaSharp and one native archive, and the two no longer
agree.
Every other platform reports that split as a startup exception with a message of its own.
WebAssembly links the native side statically at build time, so it surfaces instead as a wall of
`wasm-ld: undefined symbol: sk_*` lines naming entry points the application never wrote, with
nothing pointing at the version that caused them.
The check now ships as `buildTransitive`, so it reaches consumers who referenced `Pysar.Uno` or
`Pysar.Blazor` rather than `Pysar` itself — those are the ones who end up on a browser head.
Declaring a dependency on the native package would fix it silently, but it is a 67 MB download
charged to every WPF, console and Uno desktop consumer that will never link a wasm binary.
## Breaking changes
- `PysarUno.Use(...)` and `PysarUno.UseAsync(...)` are removed. Use `Application.UsePysar(...)` /
`UsePysarAsync(...)` instead.
## Other
- Docs updated: root `README.md`, `src/Pysar.Uno/README.md`, `docs/quick-start.md`.
- New `AGENTS.md`; added `opencode.json`.
- Tests: `UnoRegistrationTests`, `MeasureProbeCachingTests`, and a new `PackageLayoutTests`
assertion for the `buildTransitive` payload.
**Full Changelog**: https://github.com/MriyaLab/Pysar/compare/v0.1.38...v0.1.42