Skip to content

v0.2.0

Latest

Choose a tag to compare

@github-actions github-actions released this 12 Nov 17:52
· 168 commits to main since this release
b7e61be

Added

  • Custom editors can see the character that opened the edit (#34). New CellEditorContext (Value, Bounds, InitialCharacter, Culture), KumikoColumn.EditorFactory (takes precedence over CustomEditorFactory), EditorDescriptor.CreateEditor(CellEditorContext) (virtual; forwards to the existing method) and ICellEditorProvider.CreateEditor(CellEditorContext) (default interface method; forwards to the existing method). Existing factories, descriptors and providers keep working but receive no character; TextEditorDescriptor and the template-column text fallback show it.

  • IValueEditor (Value, HasValue, IsDirty), implemented by every built-in editor; a custom editor implements it to have its value committed (#33). DrawnScrollPicker takes display/value pairs (SetItems(displayTexts, values), ItemValues, SelectedItemValue, SelectValue, ClearSelection), and DrawnDatePicker.TimeOfDay keeps an edited cell's time of day.

  • Validation surface (#32): EditSession.ValidationFailed (CellValidationEventArgs) reports every error, warning or informational message with its severity and whether the value was committed, and the editor shows the message under the cell with an icon and a red (error) or orange (warning) outline. KumikoValueConverter.TryConvert is public. See "Validation" in the README.

  • Text-input contract and a rewritten DrawnTextBox (#39):

    • ITextInputSession (KumikoUI.Core.Input) is what a host's native text-input adapter drives: committed text, input-method composition (SetComposition, CommitComposition, CancelComposition), grapheme-wise deletion and selection, with KumikoTextRange for ranges and TextInputStateChanged for changes made in Core. EditSession.ActiveTextInput exposes it for the open editor. The contract is described in docs/TEXT-INPUT.md; the host adapters follow in #40–#43.
    • DrawnTextBox keeps the caret and selection on grapheme-cluster boundaries, so Backspace, Delete and the arrow keys treat an emoji sequence, a flag or a letter with combining marks as one character, and a surrogate pair is never split. It underlines composition text, and applies NumericOnly, InputMask, InputValidator and MaxLength (cut at a grapheme boundary) to typed, pasted and composed text alike. Pasted text is single-line.
    • Undo and redo (Ctrl/Cmd+Z, Ctrl/Cmd+Shift+Z, Ctrl/Cmd+Y, Undo(), Redo()): typing is undone a word at a time, a run of deletes as one step.
    • Double click selects a word, triple click selects all, and dragging selects text and scrolls past the edges; Ctrl/Cmd+Left/Right and Ctrl/Cmd+Backspace/Delete work by word; Left/Right collapse a selection to its edge.
    • EditSession.ClipboardCopyRequested and ClipboardPasteRequested carry the editor's copy, cut and paste to the host.
    • KumikoKeyEventArgs.Text carries text input as a string (a surrogate pair or dead-key sequence arrives whole), KumikoKeyEventArgs.HasCommand is Control or Command, and KumikoKey.Y is mapped on Uno for redo.
    • Caret hit-testing is a binary search over cached text widths instead of measuring every prefix on every click.
  • Safe, culture-aware comparison (#15): KumikoComparer orders any two cell values without throwing (nulls first; numbers by value across numeric types; DateTime, DateTimeOffset and DateOnly chronologically; same-type IComparable; otherwise by text, then type name). KumikoSource.Comparer, KumikoSource.Culture (default: current culture) and KumikoSource.StringCompareOptions (default: IgnoreCase) set one rule for sorting, grouping, the filter popup's value list and search, text and parsed filter conditions, Min/Max summaries and cell formatting.

  • View change notifications (#20):

    • KumikoSource.ViewChanged (KumikoViewChangedEventArgs) is raised exactly once per change, with its kind: Redraw, Rebuild, Insert or Remove, and ViewIndex/Count for incremental changes. MapRow(oldRow) follows a row from before the change to after it (data rows by item, group rows by group), and GetViewRow(item) finds an item's row.
    • KumikoSource.BeginUpdate/EndUpdate batch changes (they nest) into one rebuild and one notification.
    • KumikoSource.SetSort(column, direction, order) sets single or multi-column sort; with ToggleSort, ToggleMultiSort and ClearSort it is the only writer of sort state.
    • ScrollState.ScrollChanged (KumikoScrollChangedEventArgs) is raised once per actual scroll offset change.
    • KumikoSource.GroupExpandedChanged (GroupExpandedChangedEventArgs.IsExpanded) is raised when a group header is expanded or collapsed.
    • The selection model and the edit session follow ViewChanged by themselves (#30, #31).
  • Native AOT and trimming support (#17). Item properties are read and written, in order, through:

    • KumikoColumn.ValueAccessor / ValueSetter delegates (and EditorDisplaySelector / EditorValueSelector for ComboBox items, DrawnComboBox.DisplaySelector / ValueSelector);
    • accessors generated for types marked [KumikoGridItem] (KumikoUI.Core.Data), by a source generator now included in the KumikoUI.Core package;
    • providers registered with KumikoAccessorRegistry.Register / AddProvider (IKumikoAccessorProvider, KumikoPropertyAccessor);
    • reflection, as before.

    Generated and delegate reads are 3–5× faster than the previous compiled expression trees, with 80% less allocation (bench/KumikoUI.Benchmarks). All four packages are marked IsAotCompatible and build with no trimming or AOT analyzer warnings; such warnings now fail the build.

  • KumikoUI.Uno: a new package hosting the grid on the Uno Platform (Windows App SDK, desktop on Windows/macOS/Linux, WebAssembly, Android, iOS) with the same engine, rendering and features as KumikoUI.Maui, plus KumikoFonts for registering custom fonts from app assets, and the SampleApp.Uno sample.

  • KumikoStyle.PinBottomSummaryRows (default true): Position=Bottom table summary rows are pinned to the bottom of the viewport as a fixed footer instead of scrolling after the last row. Behavior change for existing users of bottom summaries; set it to false to restore the previous layout.

  • Localization (#47): KumikoStrings (a record, KumikoStrings.Default is English) holds every piece of text the grid draws or reports on its own: the group panel label, the blank group header, default summary labels, the filter popup and the validation messages. Set it with KumikoSource.Strings, which rebuilds the view. KumikoValueConverter.TryConvert has an overload that takes the strings, and DrawnDatePicker.Culture (set by the grid's date editor) selects the culture of the picker's month names, day names, AM/PM designators and displayed date. See "Localization" in the README.

  • KumikoSelectionModel.ClearSelectionOnEmptyAreaTap (default true), also ClearSelectionOnEmptyAreaTap on the MAUI and Uno KumikoDataGrid: a tap on the empty part of the rows area (below the last row, right of the last column) commits an open edit and clears the selection and the current cell (#45).

  • KumikoInputController.WouldHandleTab(selection, source, backwards) tells a host whether Tab would be handled before it processes the key, for hosts that must claim Tab up front (#45).

  • Space toggles the current Boolean cell when its column is editable (not read-only, edit triggers not None); on other cells it still toggles the row's selection (#45).

  • MVVM selection surface on both hosts (#55): SelectedItem, SelectedItems (an owned ObservableCollection kept in sync, or your own bound list), SelectedIndex and CurrentCell as two-way properties, plus SelectionChanged (added and removed items), SelectionChangedCommand and SelectionChangedCommandParameter. They follow items through sort and filter. Core gains KumikoSelectionBinder (the shared sync logic), KumikoSelectionModel.SetSelectedItems (replace the selection in one change) and KumikoSelectionModel.CurrentCellChanged.

  • Bindable options and commands on both hosts (#58): GroupDescriptions and GroupSummaryRows (XAML-addable collections synced to the data source), AllowRowDragDrop, ShowRowDragHandle, ShowHorizontalGridLines, ShowVerticalGridLines and AlternateRowBackground (nullable: null leaves the value to the style or theme, a value overrides it and is re-applied after Theme or GridStyle changes), CellValidator, and RowTappedCommand, CellValueChangedCommand and SortChangedCommand (event arguments as the parameter). The control now re-surfaces SortChanging, SortChanged, FilterChanging, FilterChanged, ViewChanged, GroupExpanding, GroupExpandedChanged, RowReordered, ColumnReordered, ColumnResized and ValidationFailed, and has a public thread-safe Invalidate() that repaints without a refresh. The Uno control gains Theme to match MAUI. Core gains KumikoStyleOptions, KumikoCommands.TryExecute and KumikoSource.SetGroupDescriptions / SetGroupSummaryRows (one rebuild, one notification). The README has a host property, command and event reference.

  • IInteractiveCellRenderer (OnCellTap, OnCellActivate, RedrawRequested): a cell renderer whose cell is acted on without an editor. ActionButtonsCellRenderer implements it, is IDisposable, and listens to its commands' CanExecuteChanged through weak listeners. KumikoRenderer is IDisposable and raises RedrawRequested for such renderers (the MAUI and Uno grids redraw on it) (#35).

  • KumikoStyle.ActionButtonDisabledBackgroundColor and ActionButtonDisabledTextColor, with values for the Light, Dark and HighContrast themes: the look of an action button whose command cannot execute (#35).

  • SkiaResourceCache (KumikoUI.SkiaSharp) keeps the SKPaint, SKFont and SKTypeface objects a grid draws with across frames (#62). Pass it to the new SkiaDrawingContext(SKCanvas, SkiaResourceCache) constructor each frame; disposing the context ends the frame and keeps the objects. The cache is bounded (least recently used eviction, MaxPaints/MaxFonts/MaxTypefaces, defaults 512/128/32), disposes only what it created (never SKTypeface.Default or registered typefaces), and Clear() empties it. SkiaDrawingContext(SKCanvas) still works and uses a private cache disposed with the context.

  • SkiaFontRegistrar.Unregister(family) and SkiaFontRegistrar.Version (#62).

  • Frame-time overlay (#70): ShowFrameStats (a MAUI BindableProperty, a Uno DependencyProperty, and KumikoRenderer.ShowFrameStats) draws the render time, frames per second and bytes allocated per frame in the grid's top-right corner. It is off by default, costs one boolean check per frame when off, and when on updates its text four times a second (KumikoFrameStats, readable through KumikoRenderer.FrameStats), so it allocates nothing per frame. The Large Data page of both sample apps has a toggle.

  • Benchmarks and performance budgets (#70): bench/KumikoUI.Benchmarks gains sort (int, string, date, two columns), text and numeric filter, one- and two-level grouping with summaries, combined sort/filter/group, incremental ObservableCollection add and remove, ComputeColumnWidths and scrolling-frame benchmarks, all with [MemoryDiagnoser] on deterministic data; PerformanceBudgetTests guards allocation budgets for the data pipeline on 100 000 rows in CI; a manual and weekly Benchmarks workflow uploads the results as an artifact. Budgets and measured numbers are in bench/README.md.

  • Per-column first sort direction (#173): KumikoColumn.InitialSortDirection (KumikoSortDirection?, null: the column type's default) sets the direction of the first header tap, and KumikoColumn.FirstSortDirection reports the direction in effect. KumikoStrings.SortBooleanCheckedFirst and SortBooleanUncheckedFirst ("Sort Checked First" / "Sort Unchecked First") label the filter popup's sort rows of Boolean columns.

  • Sticky group headers (#174): KumikoStyle.StickyGroupHeaders (default true) pins the header of the group the top rows belong to at the top of the data area while its rows scroll; nested levels stack (the outermost on top) and the next group's header pushes a pinned header up. A pinned header can be tapped to expand or collapse its group (collapsing it keeps the header at the top), and keyboard navigation keeps the current row below the pinned headers. Rendering stays allocation-free. Visible behavior change for every grouped grid; set GridStyle.StickyGroupHeaders = false to let group headers scroll away as before.

  • IDrawingContext.FillPolygon(ReadOnlySpan<KumikoPoint>, KumikoPaint) and DrawPolyline(ReadOnlySpan<KumikoPoint>, KumikoPaint) (round joins and caps) (#118). Both are default interface members, so existing IDrawingContext implementers keep compiling; the defaults fall back to DrawLine (outline only). SkiaDrawingContext overrides them with one reused SKPath, so drawing a glyph allocates nothing.

  • Hover cursors (#181). KumikoInputController.Cursor (KumikoCursor: Default, ResizeHorizontal, Hand) is the cursor for what is under the mouse: a left-right resize cursor over a column resize grip and for the whole of a resize drag (re-evaluated on release), a hand over a filter icon, a group chevron, a grouping chip or its remove button, the row drag handle, an editable check box or an enabled action button, and the arrow elsewhere; CursorChanged is raised only when it changes. The Uno control shows it through ProtectedCursor (Windows, desktop and WebAssembly heads), the MAUI control on Mac Catalyst (NSCursor, with a UIHoverGestureRecognizer for hover moves) and Windows (ProtectedCursor on the canvas); touch platforms ignore it. InputAction.Hover (a move with no button pressed) and InputAction.Exited (the pointer left the grid, which resets the cursor unless a resize is in progress) are new; IInteractiveCellRenderer.HasControlAt (default false) tells the grid where a hand cursor belongs, and ActionButtonLayout.IndexAt finds the button under a point without allocating. Hover hit-testing does not allocate.

  • Uno: KumikoDataGrid has a UI Automation peer (DataGrid control type, name from GridDescription or KumikoStrings.AccessibleGridName, computed or GridHint help text) and, like MAUI, GridHint and AnnounceChanges with announcements for the current cell, sort changes, edits and validation errors; GridDescription is nullable. The hidden keyboard proxy is marked AccessibilityView.Raw and no longer takes pointer input. (#78)

  • MAUI: the hidden keyboard proxy is out of the accessibility tree. KumikoDataGrid gains GridHint and AnnounceChanges and announces the current cell, sort changes, edit start and end, and validation errors through SemanticScreenReader. GridDescription is nullable and defaults to the localizable KumikoStrings.AccessibleGridName. The texts are 13 new KumikoStrings properties, formatted by Core's KumikoAnnouncements. (#77)

  • Programmatic scrolling on both hosts: ScrollToRow, ScrollToItem and ScrollToColumn (with KumikoScrollPosition Nearest/Start/Center/End), two-way VerticalOffset/HorizontalOffset, and a Scrolled event (KumikoScrolledEventArgs). Core adds KumikoScroller, ScrollState.ScrollTo, and KumikoSource.IndexOfItem/ExpandToItem. (#56)

  • Text cells can wrap with KumikoColumn.TextWrap (Word/Character). Ellipsis truncation never splits emoji or combining sequences and no longer needs a 20 px minimum width, and line breaks in single-line cells draw as spaces. New IDrawingContext default members and KumikoTextLayout. (#23)

  • KumikoDataGrid.SetCellRenderer on the MAUI and Uno controls. (#204)

  • Clipboard: Ctrl/Cmd+C copies the selected rows as Excel-compatible TSV (KumikoDataGrid.ClipboardCopyIncludesHeaders adds a header row). Copy, cut, paste and select-all work in cell editors and the filter search box on MAUI (iOS, Mac Catalyst, Windows, and Android with a hardware keyboard) and Uno. Cut deletes only after the clipboard took the text. New IKumikoClipboard and KumikoDataGrid.Clipboard. (#44)

  • Per-glyph font fallback in the SkiaSharp renderer: text the requested font can't draw (emoji, CJK, symbols) falls back to SkiaFontRegistrar.FallbackFamilies, then to the platform font manager. SkiaFontRegistrar registers bold and italic faces per SKFontStyle, and bold or italic text whose face lacks the style is emboldened or slanted synthetically. (#74)

  • KumikoColumnType.ProgressBar draws a read-only progress bar (ProgressMinimum, ProgressMaximum, ProgressShowText, ProgressFillColor, Format), and Boolean columns can be three-state with IsThreeState: tap, Space or Enter cycles unchecked, checked and indeterminate (null), drawn as a dash. (#38)

  • Theme, GridStyle and ScrollSettings are bindable on MAUI and Uno (including Theme="{AppThemeBinding Light=Light, Dark=Dark}"), and Uno gains Theme. The new FollowSystemTheme, on by default until a theme or style is set, follows OS light/dark changes at runtime, so a default grid is dark in a dark app. RowHeight/HeaderHeight and other style overrides now win over a theme or style regardless of XAML attribute order. (#57)

  • Uno: KumikoDataGrid.RenderMode (KumikoRenderMode) selects the GPU-backed SKCanvasElement (Skia-rendered heads) or the SKXamlCanvas fallback. (#65)

  • CI collects code coverage for KumikoUI.Core and KumikoUI.SkiaSharp, publishes a coverage summary and report artifact, and fails when coverage drops below the checked-in baseline (eng/coverage/baseline.json). Microsoft.NET.Test.Sdk is updated to 18.12.0. (#85)

  • Host test coverage: a new KumikoUI.Maui.Tests project (bindable property to Core mapping, run on plain net10.0) and more Uno helper tests (double-tap detector, pointer timestamp and color conversion). The MAUI host tests are part of the CI and publish gates. (#84)

  • Every C# and XAML block in the README is compiled against both hosts in CI (eng/DocsSnippets, tests/KumikoUI.Docs.Snippets.*), so a renamed or removed documented member fails the build. (#87)

  • KumikoColumn.EditorIsFilterable makes a ComboBox dropdown searchable. (#46)

  • Row drag and drop: the new RowReorderRejected event reports a refused drop, dragging to the top or bottom edge autoscrolls (ScrollSettings.AutoScrollEdgeSize/AutoScrollMaxSpeed), and KumikoPointerEventArgs.DeviceType identifies touch, mouse and pen. (#99)

  • KumikoPointerEventArgs.PointerId/ScrollUnit and KumikoInputController.IsEnabled. (#60)

  • ScrollSettings.FlingHoldCutoffMs. (#72)

  • KumikoSource.DisplayColumns, ColumnLayoutVersion, GetDisplayIndex, ToDisplayIndex and ToColumnIndex. (#223)

  • KumikoSelectionBinder.Detach()/Attach(). (#59)

  • KumikoColumn.ContentFitWidth, KumikoLayoutEngine.AutoFitSampleRows and KumikoRenderer.AutoFitColumn. (#24)

  • New Core members for grid-level read-only, sorting and filtering: EditSession.IsReadOnly, KumikoInputController.AllowSorting/AllowFiltering, KumikoRenderer.AllowFiltering and KumikoHitTester.AllowFiltering. (#53)

Changed

  • Breaking: the host controls keep their children private (#52). MAUI's KumikoDataGrid derives from ContentView instead of Grid and Uno's from UserControl instead of Grid, so the layout API (Children, RowDefinitions, Add) is gone and replacing Content throws. SetItemsSource and SetColumns are removed: use ItemsSource and Columns. Columns and TableSummaryRows are never null (assigning null sets an empty collection). MAUI's HeaderHeight and RowHeight are double, like Uno's, and IsReadOnly no longer hides a base member. Uno's control has [ContentProperty(Columns)], so columns go directly inside it in XAML, as on MAUI.

  • Breaking: DrawnDatePicker.SelectedDate is DateTime? (null: nothing selected). DrawnScrollPicker.SelectedIndex can be -1 (nothing selected), and its ValueChanged reports item texts instead of indices. CellEditorFactory.GetEditorValue reads IValueEditor.Value, so a picker returns the selected item's value. An edit whose editor wasn't changed ends without writing or validating (#33).

  • Breaking: CellValueChanged is now raised after CellEndEdit (it was before), for an edit and for a boolean toggle, so a handler sees the session no longer editing and can start the next edit. A refused boolean toggle raises CellEndEdit with Committed false. Handlers that relied on the old order must change (#34).

  • Breaking: KumikoSource.SetCellValue returns bool (whether the value was written) and raises a change only on success. CellEditorFactory.GetEditorValue returns the editor's own value (a text box's text) and no longer converts it: EditSession.CommitEdit converts. CellEditorFactory.CreateEditor takes an optional culture. A warning from validation now keeps the editor open on the first commit (#32).

  • Breaking: KumikoColumn.AllowSorting now defaults to false for Template and Image columns and for columns with neither a PropertyName nor a ValueAccessor; set it to true to sort them. KumikoSource.FormatCellValue is now an instance method, so it formats in the source's Culture (#15).

  • Breaking: item-based selection (#30). KumikoSelectionModel is created for a source (new KumikoSelectionModel(source); the hosts do this) and tracks the selected items and the current cell's item and column, so the same items stay selected through sorts, filters, regrouping and collection changes, and items that are no longer visible leave the selection.

    • SelectedItems and SelectedRows are read-only sets.
    • New: Select(item), Deselect(item), SelectRange(from, to), SetCurrentCell(row, column), IsSelected(item) and CurrentItem.
    • SelectionChanged reports AddedItems and RemovedItems, and is raised only when the selected items change, not when they merely move.
    • SelectAll() and Shift ranges select only data rows (group header and summary rows are never selected); SelectAll(int) and HandleRowSelection(row, shift, ctrl, totalRows) lose their row-count parameter, and ClearSelection() is now Clear().
    • SelectionUnit, KumikoSelectionModel.Unit, SelectedCells and IsCellSelected are removed: cell selection was never implemented and is planned for 1.x (#108).
  • Breaking: KumikoSource.DataChanged (an argument-less Action) is replaced by ViewChanged. GroupCollapsed/GroupCollapsedEventArgs, which fired on expand as well, are replaced by GroupExpandedChanged. KumikoColumn.SortDirection, SortOrder and ActiveFilter are read-only outside KumikoUI.Core: use KumikoSource.SetSort, ClearSort, SetColumnFilter and ClearAllFilters. SetColumns now rebuilds the view, ReorderRow raises one notification instead of two, and a SetCellValue whose item raises PropertyChanged raises one notification instead of two. IsMultiSortActive is cached.

  • The reflection fallback for item properties is off for PublishAot=true and TrimMode=full publishes (KumikoUI.Core build targets set the KumikoUI.Core.IsReflectionPropertyAccessSupported switch). A property with no generated accessor, delegate or provider then reads as null and is traced once. Override with the KumikoReflectionPropertyAccess MSBuild property. Partial trimming, the .NET MAUI default, is unaffected.

  • A nested property path with a null value part-way (Address.City when Address is null) now reads as an empty cell instead of throwing, and an edit to it is ignored.

  • Breaking: naming pass: every grid type now uses the Kumiko prefix (drawn components keep Drawn), and no public name collides with types of MAUI, CommunityToolkit.Maui, WinUI/Uno, the Windows Community Toolkit DataGrid, WPF, Windows Forms or Avalonia (#16). Namespaces are unchanged (KumikoUI.*); member names are unchanged (for example KumikoColumn.SortDirection, KumikoDataGrid.GridSelectionMode and KumikoDataGrid.GridStyle keep their names, only their types change). Update XAML and code as follows:

    • Host control: DataGridView → KumikoDataGrid in both KumikoUI.Maui and KumikoUI.Uno, including XAML (<dg:DataGridView …> → <dg:KumikoDataGrid …>, <dg:DataGridView.Columns> → <dg:KumikoDataGrid.Columns>, and the same for TableSummaryRows and GroupSummaryRows).
    • Models: DataGridSource → KumikoSource, DataGridColumn → KumikoColumn (including <core:DataGridColumn …> in XAML), DataGridColumnType → KumikoColumnType, DataGridStyle → KumikoStyle, DataGridTheme → KumikoTheme, DataGridThemeMode → KumikoThemeMode, CellStyle → KumikoCellStyle, RowStyle → KumikoRowStyle, DataGridRenderer → KumikoRenderer
    • Selection and sorting: SelectionModel → KumikoSelectionModel, SelectionMode → KumikoSelectionMode, SelectionChangedEventArgs → KumikoSelectionChangedEventArgs, SortDirection → KumikoSortDirection
    • Primitives: GridColor → KumikoColor (and GridColorTypeConverter → KumikoColorTypeConverter), GridFont → KumikoFont, GridFontMetrics → KumikoFontMetrics, GridPaint → KumikoPaint, GridRect → KumikoRect, GridSize → KumikoSize, GridPoint → KumikoPoint, GridTextAlignment → KumikoTextAlignment, GridVerticalAlignment → KumikoVerticalAlignment
    • Input: GridKey → KumikoKey, GridKeyEventArgs → KumikoKeyEventArgs, GridPointerEventArgs → KumikoPointerEventArgs, GridInputController → KumikoInputController, GridHitTester → KumikoHitTester, HitTestResult → KumikoHitTestResult, GridLayoutEngine → KumikoLayoutEngine
    • Event arguments: TextChangedEventArgs → KumikoTextChangedEventArgs, TimeChangedEventArgs → KumikoTimeChangedEventArgs, ColumnReorderedEventArgs → KumikoColumnReorderedEventArgs, FocusChangedEventArgs → KumikoFocusChangedEventArgs, RowTappedEventArgs2 → RowTappedEventArgs (the type of RowTapped and RowDoubleTapped on both hosts and on KumikoInputController)
    • Drawn components: ComboBoxItem → DrawnComboBoxItem, FocusManager → DrawnFocusManager, CheckState → DrawnCheckState

    Apps that aliased Core's types to avoid clashes with Microsoft.UI.Xaml.Controls or Microsoft.Maui.Controls (for example using SelectionMode = KumikoUI.Core.Models.SelectionMode;) can drop the aliases.

  • KumikoUI.Uno no longer ships the KumikoUI.Uno.WindowExtensions app-icon helper that Uno.Resizetizer's source generator added to the library.

  • CI fails when a public KumikoUI type shares its simple name with another public KumikoUI type or with a type of those frameworks. The check (eng/TypeNameCheck) reads the names from pinned packages, so it needs no workloads. See "Public type names" in CONTRIBUTING.md.

  • Every public type now lives in its own source file named after it (for example KumikoStyle moved from GridState.cs to KumikoStyle.cs; the MAUI hosting extensions file is now KumikoUIHostingExtensions.cs). No API change.

  • The product is named "KumikoUI DataGrid" in all package descriptions, assembly metadata and the README.

  • Breaking: minimum OS versions raised and unified across KumikoUI.Maui and KumikoUI.Uno: iOS 17.0 (was 15.0 on MAUI, 14.2 on Uno), Mac Catalyst 17.0 (was 15.0, which current Xcode toolchains reject), Android API 24 (was 21), Windows 10.0.19041 (was 10.0.17763 on MAUI). Defined once in Directory.Build.props and re-baselined at each .NET major.

  • Breaking: SkiaSharp 4.153.1 (was 3.119.2) for KumikoUI.SkiaSharp, KumikoUI.Maui and KumikoUI.Uno, which changes the native SkiaSharp library in every consuming app. Uno apps must set <SkiaSharpVersion>4.153.1</SkiaSharpVersion> in their csproj: Uno.Sdk's implicit SkiaSharp packages default to 3.x, and the app must resolve the same major as KumikoUI. KumikoUI.Uno also references the SkiaSharp packages Uno's runtime pulls at 3.x (SkiaSharp.Views, SkiaSharp.NativeAssets.Linux, SkiaSharp.Skottie), so the whole graph resolves one major.

  • Breaking: KumikoUI.Core, KumikoUI.SkiaSharp and every KumikoUI.Uno head now target .NET 10 (net10.0, net10.0-*); net9.0 is dropped because .NET 9 support ends 2026-11-10. KumikoUI.Maui already targeted .NET 10. Apps must target .NET 10.

  • Supply-chain hardening: Dependabot (NuGet and GitHub Actions, grouped weekly), CodeQL analysis, OpenSSF Scorecard, read-only workflow tokens by default, and every GitHub Action pinned to a commit SHA at its current major (checkout v7, setup-dotnet v6, upload-artifact v7, download-artifact v8, action-gh-release v3).

  • Releases are gated: publishing requires approval in the nuget-publish environment and passing Core and Uno test suites; main and v* tags are protected by rulesets kept in .github/settings/. CI now runs on every pull request to main, including documentation-only changes, and no longer runs for develop.

  • Package versions come from git tags (MinVer); project files no longer contain <Version>1.0.0</Version>, so a local dotnet pack now produces a prerelease such as 0.2.0-alpha.0.8 instead of a misleading 1.0.0. Copyright metadata uses a fixed year, and symbol packages are produced by default.

  • KumikoUI.Uno package description no longer claims a Mac Catalyst head (macOS is served by the desktop head).

  • KumikoUI.Maui now declares an explicit minimum of Microsoft.Maui.Controls 10.0.20 instead of whatever MAUI version the build machine had installed.

  • KumikoUI.Uno is built with Uno.Sdk 6.7.30 (was 6.5.31).

  • The filter popup's sort rows depend on the column type: "Sort A to Z" / "Sort Z to A" for text, "Sort Smallest to Largest" / "Sort Largest to Smallest" for Numeric and "Sort Oldest to Newest" / "Sort Newest to Oldest" for Date columns (#47). Summary values are formatted in KumikoSource.Culture instead of the current culture, and the date picker draws the culture's day and month names and AM/PM designator (an empty designator draws none) instead of English text (#47). The hit test of the group panel sizes the label from the configured text. A summary Format with a formatted placeholder ("Total {0:N1}") is applied as a composite format instead of producing garbled text.

  • KumikoUI.Uno package hygiene (#66): the package no longer carries the Android resource pipeline's AndroidX content (it ships lib/ only, plus the README and icon), and its dependencies are limited to KumikoUI.Core, KumikoUI.SkiaSharp, Microsoft.Extensions.Hosting.Abstractions, Uno.WinUI and the SkiaSharp packages. Uno.WinUI.Lottie and Uno.WinUI.Graphics2DSK are no longer handed on to consuming apps (an app requests them through its own UnoFeatures). The description and tags now name the WebAssembly, desktop, Android and iOS heads. eng/check-uno-package.sh runs in CI after the pack and fails on content entries, a package over 2 MB, unexpected dependencies or missing metadata.

  • Breaking: keyboard and tap contract (#45):

    • Tab and Shift+Tab are no longer a keyboard trap. With no current cell, or past the last (before the first) tab stop, HandleKey leaves Tab unhandled and the hosts move focus to the next (previous) control; an open edit is committed first. Tab only opens the editor of the cell it lands on when that column's edit triggers are not None.
    • Enter outside an edit opens the editor of the current cell, like F2 (the F2Key trigger); when it can't, Enter is left unhandled so the page's default button works. Escape outside an edit is left unhandled when there is nothing to clear.
    • Boolean cells: a single tap toggles only on the check box (anywhere in the cell with the SingleTap trigger); the second tap of a double-tap toggles with the DoubleTap trigger unless the first tap already did, so a double-tap toggles once. EditTriggers=None and read-only columns never toggle. Before, every tap anywhere in the cell toggled, even with EditTriggers=None, and a double-tap toggled twice.
    • A tap on the empty area below the rows now clears the selection; set ClearSelectionOnEmptyAreaTap to false to keep it.
  • Breaking: ICellRenderer.Render takes the cell as one CellRenderContext passed by reference: Render(IDrawingContext ctx, in CellRenderContext cell) replaces Render(ctx, cellRect, value, displayText, column, style, isSelected, cellStyle) (#68). The context carries the same values (Bounds, Value, DisplayText, Column, Style, IsSelected, CellStyle) plus the visible Row, the grid's shared paints (Paints, a PaintCache), and the cell's TextPaint and TextAlignment with its style overrides applied, so a renderer can draw without allocating. Custom renderers change their signature and read the values from cell; see "Custom cell renderers" in the README.

  • Behavior change: the grid caches the display text of the cells it draws (#68). A cell is read and formatted again when its item raises PropertyChanged, its row shows another item, the view is rebuilt, the collection is reset, SetCellValue writes it, the culture changes, or the column's Format, PropertyName or ValueAccessor changes. An item that doesn't implement INotifyPropertyChanged and is changed outside the grid now shows its new values after KumikoSource.Refresh() instead of on the next repaint.

  • Column headers reserve room on the right only for the glyphs they draw (#68): 12 px for the sort arrow only while the column is sorted, and 14 px for the filter icon when the column allows filtering. The filter icon of an unsorted column moves into the free sort-arrow slot, so a header title is no longer cut short for an arrow that isn't there.

  • Summary rows (#19). Breaking: an exact decimal total replaces the double one. Sum and Average of decimal values compute in decimal (0.1 + 0.1 + 0.1 is 0.3, not 0.30000000000000004) and ComputedSummaryRow.RawValues then holds a decimal; integers and floating-point numbers still give a double. Values that are not numbers (text, dates, booleans) are skipped by a type-code switch instead of one caught exception each, so a Sum over a 100K-row text column is cheap. Several aggregates of one property no longer overwrite each other: the README's Sum plus Average example of one column shows both, joined in declaration order in that column's cell (Sum: 650 | Avg: 162.5; the summary row keeps one line, so its height does not change). ComputedSummaryRow.Values and RawValues are keyed by property name, case-insensitively, and RawValues holds the first aggregate of a property; the new Aggregates (ComputedSummaryValue: property, type, label, raw value, text) and GetRawValue(property, type) give every one. A summary can aggregate a property that has no column or a hidden one. GroupSummaryRow.Levels (GroupSummaryLevels.Innermost, the default, or All) shows a group summary after the groups of every level, each summarizing the rows beneath it.

  • Breaking: a tap on an action-button cell runs the button without opening an editor (#35). A column whose renderer is an ActionButtonsCellRenderer (and that has no EditorFactory, CustomEditorFactory or EditorDescriptor) never opens an editor from a tap, double-tap, long press, F2 or typing, so CellBeginEdit, CellEndEdit, CellValueChanged and the view change a commit caused no longer fire from a button tap, and EditTriggers and IsReadOnly no longer matter for it. Enter on the current action cell runs its first button when enabled; Space still toggles the row's selection. To keep the old editor behavior, set CustomEditorFactory to create a DrawnActionButtons.

  • The MAUI and Uno grids keep one SkiaResourceCache per control (#62): steady-state frames create no native Skia objects (3,416 B to 40 B allocated per frame in bench/KumikoUI.Benchmarks, about 8% faster). The cache is disposed when the MAUI handler disconnects or the Uno control unloads and created again on the next frame.

  • SkiaFontRegistrar.IsRegistered is a single hash lookup instead of a scan of the registry (#62).

  • Breaking: the first header tap sorts by the column type (#173): Boolean columns checked first (Descending) and Date columns newest first (Descending) instead of ascending; text, numbers, ComboBox and Picker columns still sort ascending. The tap cycle starts from that direction (first direction, then the opposite one, then none), for single and Shift/Ctrl multi-column sorts alike. The filter popup's two sort rows are now "first-tap direction, then the opposite": Date columns show "Sort Newest to Oldest" first and Boolean columns "Sort Checked First" / "Sort Unchecked First" (they showed "Sort A to Z" / "Sort Z to A"); set InitialSortDirection to restore ascending-first.

  • Breaking: column headers are no longer truncated unless the column has an explicit width (#182). A column whose Width was never set is at least its header-fit width: the header text measured in the header font, the header padding on both sides, 12 px for the sort arrow when the column can be sorted (sorted or not), 14 px for the filter icon when it can be filtered, and a 4 px margin. Default (Fixed and Auto) columns with a long header are therefore wider than 120 px, and Star columns never shrink below their header: a Star column held at its minimum or maximum leaves the rest to the other Star columns, and when the viewport is too narrow for every minimum the grid scrolls horizontally. Setting Width (in code or XAML, by dragging the resize grip, or by double-click auto-fit) makes it explicit (KumikoColumn.HasExplicitWidth): the column keeps that width and truncates its header with an ellipsis as before; a MaxWidth below the header-fit width also wins. Default-width columns now honor MinWidth and MaxWidth, and MinWidth above MaxWidth no longer throws (the minimum wins). Header widths are measured once per header text and font and cached, so rendering stays allocation-free. New API: KumikoColumn.DefaultWidth, HasExplicitWidth and HeaderFitWidth; KumikoLayoutEngine.ComputeColumnWidths(columns, viewportWidth, measuringContext, style), UpdateHeaderFitWidths, MeasureHeaderFitWidth and EffectiveMinWidth. Auto-fit (CalculateAutoFitWidth) is never narrower than the header-fit width.

  • Breaking: KumikoInputController.CursorChanged is an Action<KumikoCursor> (it was an Action<bool>, true for the resize cursor) and is raised only when the cursor changes (#181).

  • A column whose MinWidth equals its MaxWidth has no resize grip: a press on its header edge is a header tap (#181).

  • Breaking: DrawnDatePicker and DrawnNumericUpDown are culture-aware and accept typed entry. DrawnNumericUpDown.UpdateAutoRepeat is removed (use UpdateAnimation), and the date picker's default format is now the culture's short date instead of a fixed pattern. The calendar follows the culture's first day of the week, names and date order; dates and numbers can be typed and are validated through the edit session; held +/- buttons and arrow keys repeat with acceleration; and min/max limits (MinDate/MaxDate, Minimum/Maximum) are enforced, with disabled days drawn dimmed. (#48)

  • Breaking: KumikoSource.ReorderRow returns KumikoReorderResult and refuses sorted views, sources that aren't a writable, resizable IList, and moves across groups (rows move within their group). RowReordered fires once, after a real move. (#99)

  • Breaking: the mouse wheel is no longer always reported as handled: the page scrolls once the grid reaches its end, and Shift+wheel scrolls horizontally. A host handler that relied on the grid always consuming the wheel must change. (#60)

  • Breaking: FollowSystemTheme is on by default, so a grid whose Theme and GridStyle are unset now follows the OS light/dark appearance instead of staying light. Set FollowSystemTheme="False" or set a theme to keep a fixed look. (#57)

  • MAUI: builder.UseKumikoUI() is the single hosting entry point. It registers SkiaSharp and the canvas handler and bridges ConfigureFonts aliases into the grid renderer, and KumikoDataGrid throws a clear error if it wasn't called. UseSkiaKumikoUI() is obsolete. (#51)

  • Each package ships its own NuGet README (plain Markdown with absolute image URLs, from docs/nuget/) instead of the GitHub README, so the nuget.org pages render. Package tags are corrected: KumikoUI.Core and KumikoUI.SkiaSharp are no longer tagged maui. (#95)

  • CI publishes a Native AOT console smoke app (Linux, Windows, macOS), the MAUI sample with Native AOT (iOS, Mac Catalyst) and the Uno WebAssembly sample trimmed. Apps in the repository now get the KumikoUI.Core build targets, so the reflection fallback is off under AOT, and the sample row types use [KumikoGridItem] accessors. (#76)

  • README rewritten for both hosts: side-by-side .NET MAUI and Uno getting started, all four packages, a supported-platforms matrix, a per-platform keyboard matrix, an accessibility statement, an FAQ, and a KumikoStyle reference generated from source. Every C# and XAML snippet compiles against both hosts, and unmeasured or inaccurate claims are removed. (#86)

  • SizeMode=Auto columns fit their header and widest cell, and resizing or auto-fitting a Star or Auto column switches it to Fixed so the width persists. Auto-fit (CalculateAutoFitWidth) samples the rows on screen plus the first and last 100 instead of measuring all rows. (#24)

  • Publishing uses NuGet Trusted Publishing (OIDC) instead of a stored API key, every package must ship a symbol package, the CHANGELOG section becomes the GitHub Release body and PackageReleaseNotes, and manual publish runs have a dry-run mode. (#92)

  • Repository: the showcase GIF shrinks from 15 MB to 2.7 MB, leftover .NET/Uno template files are removed, test, coverage and .claude/ output is ignored, and LICENSE uses "Eight-Bot, Inc." consistently. (#94)

  • KumikoSource is IDisposable and has Detach()/Attach(). It unsubscribes from the bound collection and every item on teardown, and item tracking is O(1) instead of a weak reference per item with O(n) untracking. The MAUI and Uno grids detach on unload and re-attach on reload. (#28)

  • Groups are keyed by the raw group key instead of display text, so keys that display the same are separate groups, and expand/collapse state is kept per key path and pruned only for the paths a group-description change invalidates. (#29)

Removed

  • Breaking: KumikoRowStyle.Height, which was never honored; variable row height is tracked in #102. (#204)
  • Breaking: Uno: the no-op UseKumikoUI(IHostBuilder) and the Microsoft.Extensions.Hosting.Abstractions dependency; Uno needs no startup call, so delete the call. (#51)

Fixed

  • Editing no longer loses input or leaves two editors (#34):

    • EditSession.BeginEdit while an edit is open commits it first and returns false, keeping the open editor, when the commit is refused; the old editor is ended and removed from focus before the new one is created, so the focus manager holds exactly one editor.
    • A refused commit now blocks the gesture that would end the edit: a tap or long press on another cell, Tab, Enter, and Up, Down, Home, End, PageUp or PageDown that the editor leaves alone. The selection stays, the editor stays focused and shows its message. Before, the selection moved while the editor stayed open, or the edit was silently dropped.
    • ToggleBooleanCell runs the validation pipeline of CommitEdit (CellValidator, the write, the item's own validation with rollback, ValidationFailed) and raises CellValueChanged only after a successful write; it commits an open edit first.
    • DrawnFocusManager.Unregister of the focused component now blurs it (OnLostFocus, FocusChanged).
  • Editors never commit a value the user didn't choose (#33). Before, opening an editor and leaving it (a tap elsewhere, Tab, Enter) overwrote the cell and raised CellValueChanged:

    • a combo box whose value wasn't in its list wrote null;
    • a scroll picker wrote its first item;
    • a date picker on an empty cell wrote today, and any picked date lost its time of day;
    • a custom editor wrote null.

    Now CommitEdit writes only when the editor has a value the user changed, and only when it differs from the original. Combo boxes and pickers start with nothing selected when the cell's value isn't in their list; they match enum values to names. The date picker opens empty on an empty cell, keeps the original time, and reads DateOnly. Enter confirms in the date and scroll pickers. A scroll picker no longer coasts past the item its release confirmed, and Up/Down at the ends no longer report a change.

  • Typed value conversion and validation (#32):

    • Conversion to the property type. Edited text converts to the property's type in KumikoSource.Culture: every numeric type, decimal at full precision (it went through double), enums by name, Guid, DateOnly, TimeOnly, DateTimeOffset, TimeSpan, bool, char, string and nullable forms. The date picker writes DateOnly properties.
    • No more silent failures. Out-of-range numbers, fractions in integer properties (they were rounded), unparsable text, blank text for a non-nullable property, and setters that throw are now errors with a message. They used to be dropped silently while the commit reported success.
    • Item validation sees the new value. IDataErrorInfo/INotifyDataErrorInfo are checked after the new value is written, and the original value is restored on an error. Before, they saw the old value.
    • Both validators run. A passing CellValidator no longer skips the item's own validation.
    • Warnings are shown. A first commit shows the warning; committing the same value again accepts it.
    • Editing text. Editors show values in the grid's culture, without the display format, so they parse back.
    • No-value editors. Editors that hold no value (action buttons), and columns with nothing to write to, end the edit without writing null into the item.
  • Filter popup (#49):

    • Scrolling: the value list scrolls. It can be dragged, scrolled with the mouse wheel, moved with a draggable scrollbar (a press on its track jumps), and stepped through with the keyboard: Up/Down, PageUp/PageDown, Space to toggle, Enter to apply, Escape to cancel. Previously only the first values were reachable.
    • Press and release: an item toggles on release, and only if the pointer didn't move past a small threshold, so dragging no longer flips checkboxes. Buttons act on release over the same button.
    • Large lists: only the visible rows are drawn, and the search is applied once per frame however fast you type, narrowing the current matches as the search text grows. A column with 10,000 distinct values opens in about 30 ms.
    • Search box: it is a DrawnTextBox, so it follows the theme (it was always white), edits by grapheme cluster, supports undo, and drives the text-input contract (DrawnFilterPopup.SearchTextInput, KumikoInputController.ActiveTextInput).
    • Following the column: the popup follows its column when the grid scrolls, and draws one shadow instead of two.
  • Popups (PopupManager):

    • A press outside a popup closes it and does nothing else: it no longer also selects a cell, starts an edit or sorts. PopupClosed reports every close, so KumikoInputController.FilterPopupClosed is now raised for an outside tap too.
    • A press inside a popup captures the pointer until release.
    • The mouse wheel reaches the popup under it (DrawnComponent.OnScroll).
    • Z-order only increases.
    • Show accepts an anchor function, which popups re-read before each frame (UpdateAnchors).
  • Conditional styles no longer leak (#22). A RowStyleResolver text color or font was written into the column's shared CellStyle (permanently recoloring the column for every row), and into a CellStyleResolver result (corrupting cached instances). The effective cell style is now composed into a separate instance; the column's style and resolver results are never modified. The cellStyle passed to ICellRenderer.Render may be reused for the next cell, so renderers must not keep or modify it.

  • Incremental updates and item change notifications (#21). Adding or removing one item of an ObservableCollection now honors SetFilter predicates and column filters: an added item the filter rejects no longer becomes a row, and removing a filtered-out item no longer forces a rebuild (the view only shifts its indices; such a change raises a Redraw). PropertyChanged with a null or empty name, with a parent of a nested path (Address for a column, group or summary on Address.City; the item must raise it, as nested objects are not observed), or with any name while a SetFilter predicate is set, now rebuilds the view; two columns sharing a property both count, only an active filter counts, and names match ignoring case, as column bindings do. DefaultGroupExpanded rebuilds when grouping is active and the value changes, and SetFilter(null), ClearAllFilters() and SetColumnFilter(column, null) raise nothing when there was no filter.

  • Sorting, grouping and filtering never throw on mixed or non-comparable values (#15). Tapping the header of a Template or action column (whose value is the whole row item) no longer crashes; a column holding both int and double sorts by value instead of throwing; Min/Max summaries over mixed numeric types work. Sorting is stable, so rows with equal keys keep their source order. Groups are ordered by their key (1, 2, 10; dates chronologically) instead of their header text, and header text uses the column's Format. Group buckets, the filter value list and value filters follow the same case rule as sorting, so "Oslo" and "oslo" are one group and one filter value by default.

  • Heterogeneous item lists (subclasses mixed in one list, for example a List<Animal> of Dog and Cat) sort, filter, group and summarize correctly: every column property is resolved per item type (fixed by the per-type accessors of #17, now covered by tests). A null item in the source collection is skipped, as if a filter rejected it, instead of crashing the first render (#18).

  • Editing tracks the edited item and column instead of a visible row index (#31). An edit that outlives a sort, filter, grouping change, collection change or column reorder now commits to the item it was opened on, wherever its row is, instead of writing whatever item sits at the old row (or throwing). An edit whose item is filtered out, collapsed or removed is canceled. Sorting, filtering, group toggles and drag-reorders from the grid commit an open edit first, and are ignored while its value is invalid. The editor overlay moves with its cell when the grid scrolls and hides while the cell is out of view (UpdateEditorBounds was never called). SetCellValue, ToggleBooleanCell and starting an edit ignore rows that are out of range or not data rows. EditSession exposes EditItem and EditColumn, and follows the source's ViewChanged by itself while an edit is open.

  • ComboBox editors now apply the column's EditorDisplayMemberPath and EditorValueMemberPath; they were set after the items were built, so items showed ToString() and the current value was not selected.

  • An unknown font family now falls back to the default family in the requested weight and slant instead of producing a null typeface. Styled typefaces are resolved through SKFontManager with an explicit family, which SkiaSharp 4 needs to keep bold and italic.

  • Taps on the pinned summary footer no longer select or edit the data row behind it; unpinned bottom summary rows are also reported as HitRegion.TableSummaryRow.

  • Keyboard navigation keeps the current row fully visible between the header/frozen rows and the pinned footer, and accounts for the grouping panel and top summary rows (previously the scroll offset was counted twice).

  • Row drag-handle grips no longer paint over the pinned summary footer.

  • An unknown font family no longer crashes the SkiaSharp backend: a family the platform cannot resolve (SkiaSharp returns null on Android and Windows, for example for a MAUI font alias) falls back to the default typeface in the same weight and slant, the fallback is what gets cached, and disposing the drawing context is null-safe and never disposes the shared default typeface. Each unknown family is logged once through Trace.TraceWarning (#73).

  • Scrolled rows no longer paint over the "Grouped by:" panel when the grid has no frozen columns (#117). Every row pass is now clipped vertically to the data area (below the header and top summaries, above a pinned footer) whether or not columns are frozen, and the visible-row range starts at the first row that intersects the data area instead of a few rows above it.

  • SampleApp.Maui no longer crashes at launch on Mac Catalyst (macOS 27) and iOS 27: it adopts the UIScene lifecycle with a UIApplicationSceneManifest in both Info.plist files and a SceneDelegate (MauiUISceneDelegate), as current .NET MAUI templates do (#121). README notes this for apps hosting KumikoUI.

  • Keyboard navigation (#45):

    • Scrolling the current cell into view keeps a scrollable row between the grouping panel, header, top summaries and frozen rows and the pinned bottom summary footer, with every combination of them, and keeps a column between the frozen columns net of the row drag handle (it ignored the handle's width).
    • Tab's search for the next tab stop walks rows, not rows × columns cells, so a read-only grid with many rows no longer freezes on Tab.
    • Enter, like F2 and typing, scrolls the cell into view before the editor opens.
    • KumikoUI.Uno: the hidden keyboard proxy no longer marks every key handled. An unhandled Tab moves focus out of the grid (past both the grid and its proxy), and an unhandled Enter, Escape or F2 reaches the page; a key the proxy left unhandled is not sent to Core a second time by the grid.
    • KumikoUI.Maui (iOS, Mac Catalyst): the native key responder declines Tab when Core would leave it unhandled, so UIKit's focus navigation takes it. On Windows the hidden Entry already leaves Tab to the system.
  • Action buttons (#35):

    • ICommand.CanExecute is checked before Execute, for the button's CommandParameter or the row item. A button that cannot execute is drawn disabled and does nothing when tapped, in the cell and in the DrawnActionButtons editor; CanExecuteChanged redraws the grid.
    • A command that removes its own row, even the last one, no longer throws from the tap handler: the tap reads nothing about the row after the command runs.
    • A button tap no longer commits an edit through EditSession (it raised CellBeginEdit/CellEndEdit and rebuilt the view).
  • SkiaFontRegistrar changes are safe while grids are alive (#62): registering, replacing, unregistering or clearing a family first makes every grid's cache drop that family's typefaces and fonts, then disposes what the registrar owned, so a frame never draws with a disposed typeface and the next frame uses the new registration. Replacing a family registered from a stream disposes the old typeface instead of keeping it until Clear(). The text-measuring context used for column auto-fit is disposed.

  • Tab stops at every editable cell of every column type (text, numeric, date, Boolean, ComboBox, picker, template, action buttons) unless the column sets AllowTabStop = false; only read-only, hidden and opted-out columns are skipped. The core already behaved this way; the samples had opted every Boolean (and action) column out, so Tab skipped the checkboxes, and they no longer do. The KumikoColumn.AllowTabStop documentation said Tab stopped "during editing" only; it applies in normal mode too (#172).

  • Space, Enter and F2 toggle the current check box cell from the keyboard (#179). Hosts that capture the keyboard through a hidden text box (Uno, and MAUI's Entry) deliver Space as a typed character, which Core now treats as Space on a Boolean cell; Enter and F2 toggle it instead of looking for an editor it doesn't have.

  • Expand/collapse chevrons, sort arrows (column headers, grouping-panel chips and the filter popup), the grouping-panel hierarchy chevron, the combo box dropdown arrow, the date and time picker arrows, the checkmarks (boolean cells, DrawnCheckBox, filter popup items) and the filter funnel icon are drawn as one filled, anti-aliased triangle or one joined polyline each, instead of separate strokes whose corners did not meet (#118). Separate strokes (the remove "x", plus and minus, separators and the drop indicator) remain DrawLine.

  • A mouse move with no button pressed no longer scrolls the grid: the controller tracks whether a press is in progress and handles any other move as a hover. The MAUI control sends a hover move as Hover instead of Moved, and the pointer entering or leaving the canvas no longer cancels a resize, reorder or row drag in progress (it was sent as Cancelled). The Uno control forwards hover moves (it dropped them) and leaving the grid to the controller (#181).

  • Grid-level IsReadOnly, AllowSorting and AllowFiltering on the MAUI and Uno hosts now take effect. A read-only grid refuses every edit, Boolean toggle and Tab stop; AllowSorting=false stops header-tap sorting; AllowFiltering=false hides and disables the header filter icons. They combine with the per-column flags, and a grid-level false wins. (#53)

  • The MAUI and Uno grids release every subscription to app-owned collections (items, columns, summary rows, grouping, SelectedItems) and the long-press timer when they disconnect or unload, and restore them on reconnect, so a long-lived view model no longer keeps navigated-away pages alive. (#59)

  • SizeMode=Auto columns now fit their content: cells are sampled on the first frame and after data or view changes, never every row. (#24)

  • The Uno WebAssembly sample builds again: works around SkiaSharp 4.153.1 putting -std=c++20 on the Emscripten link line, which broke Uno's C shim, and makes the WebAssembly CI job blocking. (#184)

  • ComboBox and Picker editors: the open editor gets the first chance at Enter, Escape and Tab, so keyboard-only users can pick an item; arrows move the selection; typing a letter jumps to the matching item instead of restarting the edit; keys the editor ignores no longer trigger grid shortcuts (Space in a date picker no longer toggles row selection); the dropdown scrolls by drag, wheel and scrollbar; the Picker wheel coasts and snaps, and commits only on Enter, a tap on the centered item, or when it settles. (#46)

  • KumikoStyle.SelectionTextColor, GroupHeaderCountColor, GroupCountFont, CaptionSummaryTextColor, CaptionSummaryFont and SummaryRowLabelFont now affect rendering. Group headers draw the title, count and caption summary as separate runs, and table summary titles use the label font. (#204)

  • Cell editors draw with the grid's cell font (or the column's CellStyle font) instead of a fixed 13 px default. ComboBox dropdowns, DatePicker calendars and the filter popup flip above the cell when there is no room below and slide into the viewport, a dropdown shrinks and scrolls in a short grid, and an open text editor no longer allocates paints every frame. (#36)

  • Pointer and wheel input behave the same on every host: trackpads scroll by pixels (macOS, browser, Catalyst), Shift+wheel scrolls horizontally, the page scrolls once the grid reaches its end, a second finger no longer resets a drag or taps, modifier keys reach pointer events on Mac Catalyst, Android and Windows, a touch before the first paint is ignored, and IsEnabled="False" stops all input. On MAUI Windows, one wheel notch no longer scrolls hundreds of rows. (#60)

  • Inertial scrolling no longer flings after the finger rests before release, stops at content edges instead of keeping the frame loop running, ignores bad pointer timestamps, and steps by the real frame time on MAUI. (#72)

  • Left, Right, Home, End and Tab follow the on-screen column order (left-frozen, scrolling, right-frozen) and skip hidden columns; in Multiple selection mode arrow keys move the current cell without toggling rows (Space toggles); row-key lookup is O(1). (#223)

  • The grid draws left to right under a right-to-left ancestor on MAUI and Uno instead of mirroring (RTL layout isn't supported in 1.0; see #80). The filter popup opens under its column when the row drag handle is at the start, and no longer allocates. (#228)

  • Row drag and drop: on touch a swipe on a row scrolls and a long press starts the drag; mouse and pen drag past a threshold; the drag handle drags as soon as it moves. The ghost and drop indicator are correct with the grouping panel, top summaries and frozen rows. (#99)

  • Integration fixes between the 1.0 PRs: the ComboBox, Picker and DatePicker year list read trackpad pixels instead of wheel notches, screen reader announcements number columns as shown on screen (display order, hidden columns not counted), and the docs snippet tool handles x:Class pages and project-file fragments. (#237)

Performance

  • The steady-state render loop allocates nothing (#68). Redrawing a 30 × 10 visible grid into a no-op drawing context went from 24.8 KB and 11.4 µs per frame to 0 bytes and 2.9 µs, and with sorting, filtering, grouping, group and caption summaries, top and bottom summaries, a frozen column and the drag handle from 27.5 KB and 14.3 µs to 0 bytes and 3.8 µs (RenderBenchmarks in bench/KumikoUI.Benchmarks, Apple M4 Max):
    • Cell values and display text are cached per drawn row and column (see Changed), so an unchanged cell is not read, boxed or formatted again.
    • PaintCache.Update rebuilds the paints only when it is given another style instance or the style's new KumikoStyle.Version (incremented whenever a property gets a different value) changed, instead of every frame. It now also holds the paints for group, summary, chip, drag and checkbox drawing (PaintCache.CheckBoxBorder, PaintCache.CheckMark), and PaintCache.CellTextPaint reuses one paint for cells with text overrides.
    • The built-in renderers draw with shared or reused paints and fonts; ProgressBarCellRenderer also reuses its formatted labels, and ActionButtonsCellRenderer lays out its buttons without a list.
    • Row and cell background overrides, per-column header styles, group header labels, summary overflow text, multi-sort badges and group chips no longer allocate per frame, and the render path has no LINQ or boxed enumerators.
  • Uno: the grid draws through Uno's GPU-backed SKCanvasElement on Skia-rendered heads, with an SKXamlCanvas fallback selectable through KumikoDataGrid.RenderMode. Redraws are coalesced to one per frame, fling scrolling runs on CompositionTarget.Rendering only while animating, the caret redraws only at blink transitions, and display-scale changes redraw the grid. (#65)
  • Text widths and ellipsis/wrap layouts are cached across frames in SkiaResourceCache (bounded by MaxTextMeasurements, cleared on font-registrar changes), so redrawing unchanged text measures nothing. (#23)

Full changelog: https://github.com/TheEightBot/KumikoUI/blob/v0.2.0/CHANGELOG.md