* Implement visual geometry hit testing
* fix xml comment
* fix xml comment
* update api diff
* Introduced ICompositionHitTester to avoid duplicated hit test code between point and geometry
* Add geometry hit testing page to RenderDemo
* fix geometry hit testing not including stroke
* fix test
* update api and tests
* update api diff
* Update GeometryHitTestingPage with new API
* addressed reviews.
* remove nullability in GeometryHitTestResult Visual hit
---------
Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
* Add failing test for boxed booleans in compiled binding getters
Compiled-binding getters for bool properties emit 'box' on every read,
allocating a fresh object each time (#21065 reports ~300K allocations in
a real app). Add BooleanBoxes with two cached boxed values and a test
asserting that a compiled binding to a bool property produces the cached
box instances. BooleanBoxes must be public because compiled XAML IL is
emitted into user assemblies, which need to reference its fields.
* Reuse cached boxed booleans in compiled binding getters
Instead of emitting 'box bool' in the generated property-info getter,
emit a branch that returns BooleanBoxes.True or BooleanBoxes.False, so
reads of bool properties through compiled bindings no longer allocate.
Other value types keep the existing box. Applies to both the build-time
XAML compiler and the runtime XAML loader, which share this emitter.
Fixes#21065
* fix: emit cached boolean boxes into the generated per-assembly helper
The cached boxed booleans used by compiled-binding bool getters were
exposed as a new public BooleanBoxes class in Avalonia.Base, adding
public API surface that is useful only to compiled XAML. Review asked
for the boxes to stay an implementation detail instead.
Define two private static fields and a static constructor on the
XamlIlHelpers type the XAML compiler already generates into each user
assembly, and point the getter IL at those. The fields are shared by
all XAML files in the assembly, so allocation behaviour is unchanged
while no public API is added. The test now asserts box identity across
repeated reads instead of referencing the removed class.
On Android, composing/autocorrect text is written as live text while only a
composition region is tracked. IME edit operations (commitText,
finishComposingText) are queued and flushed on EndBatchEdit, but SendKeyEvent
dispatched the key immediately, bypassing the queue.
When a soft keyboard batched "commit autocorrect + press Enter", the newline was
inserted before the queued commit flushed. The commit then applied with stale
pre-newline composition indices and reset the caret to the end of the committed
word, leaving it on the previous line instead of the new one.
Route SendKeyEvent through the command queue via a new KeyEventCommand so key
events apply in FIFO order with the queued edit commands, honoring Android's
InputConnection batch-edit ordering contract. The autocorrect now commits first,
then the newline is inserted, leaving the caret on the new line. Outside a batch
edit the key is still dispatched immediately, preserving existing behavior;
hardware key input uses a separate path and is unaffected.
Fixes#21895
Co-authored-by: Emmanuel Hansen <emmausssss@gmail.com>
* [Automation] Fire property-changed events when AutomationId changes at runtime
AutomationElementIdentifiers.AutomationIdProperty was missing, so
runtime changes to AutomationProperties.AutomationId never raised
UIA_AutomationPropertyChangedEventId on Windows (or the equivalent
on macOS). UIA clients that subscribe to property changes would
silently receive stale automation IDs.
- Add AutomationIdProperty sentinel to AutomationElementIdentifiers
- Raise the event in ControlAutomationPeer.OwnerPropertyChanged
when AutomationProperties.AutomationIdProperty changes
- Add AutomationIdProperty -> UiaPropertyId.AutomationId to the Win32
AutomationNode.s_propertyMap
- Add AutomationPeer_AutomationId to AvnAutomationProperty (avn.idl)
and wire it in AvnAutomationPeer.s_propertyMap and automation.mm
- Add unit tests covering runtime AutomationId change notifications
* refactor: extract hardcoded dimensions to theme resources
Move hardcoded padding, margin, width, height, and border thickness values from individual control themes into centralized theme resources in BaseResources.xaml. This enables better theme customization and density style support while reducing duplication across control definitions.
* Rename Internal to Inner
---------
Co-authored-by: dimension-zero <info@ditech.ai>
Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
* fix(SelectableTextBlock): fix SelectableTextBlock selection for centered and right-aligned text
* Fix failing unit tests
* Let TextLayout handle out-of-bounds hit testing
---------
Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
* fix(input): fix AccessKeyHandler when no descendant control has focus
- Update IsFocusWithinOwner to use routed event's Source instead of re-querying KeyboardDevice.Instance.FocusedElement
- Allow access keys (Alt/mnemonics) to work immediately after Window opens when FocusedElement is null or owner itself
- Update shared test helpers in AccessKeyHandlerTests to populate event Source
Fixes#21806
* fix(input): address review feedback on AccessKeyHandler focus fix
- Type IsFocusWithinOwner's owner parameter as InputElement (matching
_owner) and drop the now-redundant `is Visual` check
- Fix indentation in IsFocusWithinOwner
- Add Should_Raise_AccessKey_When_Focus_Is_On_Descendant, covering the
IsVisualAncestorOf branch by raising KeyDown/KeyUp on a descendant
control instead of the owner
- Revert the no-op Source assignment in the KeyDown/KeyUp test helpers
- Shorten the comment in Should_Raise_Key_Events_For_Registered_Access_Key
---------
Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
* Add non-overlay popup support to the headless platform
When AvaloniaHeadlessPlatformOptions.UsePlatformPopups is enabled,
popups are hosted in dedicated headless top-levels positioned via
ManagedPopupPositioner instead of the parent's overlay layer.
HeadlessWindowExtensions.GetOpenPopups exposes the popups open above
a given toplevel. PointToScreen/PointToClient now account for the
window position, so popup placement can be asserted in desktop
coordinates.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
* Rename UsePlatformPopups to OverlayPopups for consistency with other platforms
Inverted semantics to match Win32/X11/macOS options; defaults to true
for now so existing headless test suites keep overlay popup behavior.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
* Expose IRef/IImageBrushSource, update build/api suppressions
* Hide IRef from image brush source API
Internalized `IRef<T>` and removed it from the `IImageBrushSource` public surface by making `Bitmap` internal. Added a `[PrivateApi]` `GetBitmap()` helper returning `IBitmapImpl?` so internal consumers can still access the bitmap without exposing ref-count internals. Updated Skia drawing code to use `GetBitmap()` and refreshed API suppression entries accordingly.
* test: add failing test for Loaded processing after handler exception
A control whose Loaded handler throws currently breaks the static
loaded-processing machinery: remaining controls in the same dispatcher
batch are skipped and, because _isLoadedProcessing is never reset,
every control created afterwards app-wide never receives Loaded.
The test attaches a throwing control between two siblings, expects the
exception to surface from the dispatcher job, and asserts that both
siblings and a control added in a later batch still get Loaded.
Issue #18742
* fix: recover Loaded event processing after a handler throws
Previously the static loadedProcessingAction iterated the pending
controls with no exception handling. If any control's Loaded handler
or OnLoaded override threw, the batch loop aborted, so:
- _isLoadedProcessing stayed true forever, and since
ScheduleOnLoadedCore only posts a dispatcher job when that flag is
false, no control created afterwards, app-wide, ever received
Loaded;
- the remaining controls in the current batch were skipped;
- the stuck processing queue retained control references (leak).
The invariant violated was that _isLoadedProcessing is true only while
a loaded-processing dispatcher job is actually scheduled or running.
Fix: process the snapshot as a drain queue (Dequeue before invoking,
because OnLoadedCore must not run twice for a control) and restore the
invariant in a finally block: requeue the unprocessed remainder, clear
the processing queue, reset the flag and post a new dispatcher job if
work remains. try/finally was chosen over catching per control so the
exception still propagates to the dispatcher as an unhandled exception
(matching WPF semantics) instead of being swallowed or aggregated,
while controls after the faulty one get Loaded on the next dispatcher
job.
Fixes#18742
* Remove MonoMac.NetStandard
(cherry picked from commit 4aac4c4168a73496b579dd28270e8d71764497c7)
* Several AOT compat issues
(cherry picked from commit e9f0a8e6d29da140f3f255e79bd199067981b0fe)
* Add UnconditionalSuppressMessage to the DataValidationViewModel
* Suppress trimming warning on WithDataAnnotationsValidation method
* Unnecessary AvaloniaXaml
* include TrimmingEnable on all sample projects
* Add missing SelfContained to the WinUI projects
* Include TrimmingEnable on DesignerSupport only for warnings analyzer, explicitly disable IsAotCompatible
* Disable trimming warnings for WinUI projects completely
* Enable back runtime marshalling for samples
---------
Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
* Allow single parameter with any type when binding to method
* Port method binding logic to ReflectionBinding
* Don't depend on the order of methods
* Handle overrides properly
* Fix nullability warning
* Add failing tests for composition gradient brush change tracking
Three defects in the unreleased CompositionBrush surface:
- Replacing GradientStops after the first commit never reaches the
server: the hand-written property registers nothing for
serialization, so the change only ships once an unrelated tracked
property dirties the brush.
- SpreadMethod has the same gap.
- A mutable Media.GradientStop crosses the batch by reference and the
render thread then reads a UI-thread object at replay time.
- A CompositionBrush resolves its server object for any compositor,
so a foreign compositor ends up sharing a resource across render
loops.
* Track composition gradient brush changes and respect compositor affinity
- GradientStops and SpreadMethod now register for serialization when
assigned, so changes made after the first commit reach the server
without waiting for an unrelated tracked property to dirty the
brush. In-place list mutation stays untracked and is documented as
requiring re-assignment.
- Non-composition gradient stops are snapshotted to
ImmutableGradientStop at serialization time instead of crossing the
batch by reference, since the render thread reads the server list at
replay time.
- Resolving a CompositionBrush for a different compositor now throws
instead of silently wiring one server resource into two render
loops. Transient contexts without a compositor keep receiving the
client brush unchanged.
* Add failing test for #14718
* Fix for AutoScrollToSelectedItemIfNecessary
* fix failing CI build and move test to the right location
* add failing test for TabItem selection of invisble tab
* introduce a helper method to figure out which item to select
when nothing was selected beforehand and AlwaysSelected is true
* ensure selection works for invisible tabcontrol
* simplify conditions
* propose: Remove redundant logic from ColorView
The TabItem now handles the correct selection of only visible items
* fix test: Need to set SelectedIndex after adding items
* re-add unused method and make it obsolete
Otherwise API-diff will fail.
* Address review
* Update tests/Avalonia.Controls.UnitTests/TabControlTests.cs
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
* Update tests/Avalonia.Controls.UnitTests/TabControlTests.cs
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
* Adress copilot review
* fix duplicate braces
* address review
* fix for failing tests on CarouselPage and TabbedPage
* address feedback
- adding more tests to avoid regressions
* Fix failing test: add UnitTestApplication.Start() to dedicated thread test
Agent-Logs-Url: https://github.com/timunie/Avalonia/sessions/fe2f1190-6d20-4982-8a03-1ae9b52ee701
Co-authored-by: timunie <47110241+timunie@users.noreply.github.com>
* Refactor SelectingItemsControl auto-scroll duplicate logic
Agent-Logs-Url: https://github.com/timunie/Avalonia/sessions/8895cb60-ef41-473c-972b-bad2483a5a77
Co-authored-by: timunie <47110241+timunie@users.noreply.github.com>
* Add new failing tests for AlwaysSelected mode
* Fix AlwaysSelected scenarios
---------
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
* fix(focus): infinite loop in tab stop search with TabNavigation=Once
`FocusManager.FindNextElement(Next|Previous)` and `TryMoveFocus(Next|Previous)` never
return when the focused element sits inside a container with
`KeyboardNavigationMode.Once`. The calling thread spins at 100% CPU forever; in a
desktop app that means a hard hang of the UI thread requiring the process to be killed.
## Root cause
The upward walk in `GetNextTabStop` / `GetPreviousTabStop` advances at the end of each
iteration with `parent = GetFocusParent(parent)`. But when the walk reaches a container
whose `TabNavigation` is `Once` (or `None`, in one branch), the code resets `parent`
from `focused` instead of from `current`:
```csharp
current = parent;
parent = FocusHelpers.GetFocusParent(focused); // focused is a loop invariant
```
`focused` never changes, so `parent` drops back down to the focused element's immediate
parent. The next iteration walks up to the same container again and takes the same
branch, so the walk oscillates between two nodes indefinitely. None of the three loop
exit conditions (`parent != null`, `!parentIsRootVisual`, `newTabStop == null`) can ever
be satisfied.
The correct form already exists a few lines below in `GetNextTabStop`, in the
structurally identical `KeyboardNavigationMode.None` branch:
```csharp
current = pIE;
parent = FocusHelpers.GetFocusParent(current); // walks up, converges
```
This changes the three remaining occurrences to match it: one in `GetNextTabStop`, two in
`GetPreviousTabStop`. The two loop initializers outside the `while` (`FocusManager.cs:647`
and `:748`) correctly keep using `focused` and are left alone.
## Reproducing it
The focused element has to be nested **at least one level below** the `Once` container.
When it is a direct child, `GetFocusParent(focused)` happens to return that same container
and the walk terminates by accident - which is likely why this went unnoticed for so long.
Minimal shape (used by both new tests):
```
StackPanel
├── StackPanel [TabNavigation=Once]
│ └── StackPanel
│ └── Button <- focused
└── Button <- expected result for Next
```
Found in a production app: FluentAvalonia's `ContentDialog` calls
`FindNextElement(NavigationDirection.Next, ...)` from its `Loaded` handler to pick an
initial focus target. With focus sitting on a nested `NavigationView` item - the `Once`
container comes from the NavigationView template - opening any dialog hung the app
permanently.
## Scope
Only the programmatic focus APIs go through this code. Pressing Tab is unaffected:
`KeyboardNavigationHandler` uses the separate, WPF-derived implementation in
`Navigation/TabNavigation.cs`, which handles `Once` correctly by passing the container
itself as the new starting point.
## Verification
- Two regression tests added to `InputElement_Focus`, covering both directions.
- Confirmed they actually catch the bug: with the `FocusManager.cs` change reverted, the
Next test ran for 90s using 89.5s of CPU and the Previous test for 60s using 59.6s
before being killed. With the fix both return immediately.
- Full `Avalonia.Base.UnitTests` suite: 2996 tests, 0 failed (2984 passed, 12 skipped).
## Not addressed here
The `Once` branches are asymmetric: `GetPreviousTabStop` returns the container when it is
focusable (`if (FocusHelpers.IsFocusable(parent)) newTabStop = parent;`), `GetNextTabStop`
has no such check. Separately, in the Previous direction this shape ends up returning the
focused element itself via the cycle fallback in `GetTabStopCandidateElement`, rather than
the element preceding the container. Both look like genuine issues, but they are
behavioural questions independent of the hang, so the Previous test only asserts that the
call terminates. Happy to follow up in a separate PR if you would like them fixed.
Co-Authored-By: Claude <noreply@anthropic.com>
* fix(focus): previous tab stop search accepted candidates after the focused element
Follow-up to the review feedback on the Previous test: asserting the exact element
exposed that `GetPreviousTabStop` could not produce it. This turned out to be a second,
independent porting error in the same code, so this commit fixes it and tightens both
tests to exact-element assertions.
## Root cause
`GetNextOrPreviousTabStopInternal` accepts an equal-tab-index candidate for the
Previous direction with:
```csharp
if (compareIndexResult < 0 || (((foundCurrent || currentPassed) || compareCurrentForPreviousElement) && compareIndexResult == 0))
```
The WinUI implementation this code is ported from (see
`CFocusManager::GetPreviousTabStopInternal`, faithfully mirrored in Uno's
`FocusManager.mux.cs`) reads:
```cpp
if (compareIndexResult < 0 ||
(((!bFoundCurrent && !bCurrentPassed) || bCurrentCompare) && compareIndexResult == 0))
```
The negations were lost in porting, inverting the condition: since `TabIndex` defaults
to `int.MaxValue`, sibling comparisons are almost always equal, so the Previous search
skipped every element *before* the focused one and accepted elements *after* it. The
Next direction's condition matches WinUI and is untouched.
## Impact
Not limited to the `Once` scenario from the previous commit - `FindNextElement(Previous)`
and `TryMoveFocus(Previous)` were wrong in a plain flat container: with focus on the
third of four buttons, the search returned a following element rather than the preceding
one, and where no following sibling existed it fell back to cycling, handing back the
last focusable element in scope (observed in the Once test as "returns the focused
element itself"). Keyboard Shift+Tab is unaffected as it uses the separate
`TabNavigation.cs` implementation.
## Tests
- `Can_Get_Previous_Element` (new): flat container, focus on target3, asserts target2 -
locks both "skip candidates after the focused element" and "keep the closest
preceding sibling" (not target1).
- `Can_Get_Previous_Element_Out_Of_Container_With_TabNavigation_Once`: now asserts the
exact element (`before`) instead of only termination, per review.
- Verified both fail with the condition reverted and pass with it.
- Full `Avalonia.Base.UnitTests`: 2997 tests, 0 failed (2985 passed, 12 skipped).
## Also spotted, not changed here
The Previous/Cycle branch in `GetPreviousTabStop` calls `GetFirstFocusableElement`
where WinUI calls `GetLastFocusableElement` (wrapping backwards inside a Cycle scope
should land on the last element). Happy to fix that here too if you want it in this PR,
otherwise I can open a separate one.
Co-Authored-By: Claude <noreply@anthropic.com>
* fix(focus): previous tab stop wrapped to the first element of a Cycle scope
Third porting divergence found while comparing this code against the WinUI original
(all three sit in the same two functions): the Previous/Cycle branch in
`GetPreviousTabStop` called `GetFirstFocusableElement` where WinUI calls
`GetLastFocusableElement`:
```cpp
// WinUI, CFocusManager::GetPreviousTabStop
if (IsValidTabStopSearchCandidate(pCurrent) && GetTabNavigation(pCurrent) == KeyboardNavigationMode::Cycle)
{
pNewTabStop = GetLastFocusableElement(pCurrent, pCurrent);
break;
}
```
Wrapping backwards inside a Cycle scope must land on the LAST focusable element,
mirroring the forward wrap (last -> first). Taking the first element instead meant
that with focus on the first tab stop of a `TabNavigation=Cycle` container,
`FindNextElement(Previous)` returned the focused element itself and
`TryMoveFocus(Previous)` was a no-op - focus could neither leave the scope (by design)
nor wrap within it (the bug).
Observed against the keyboard-path reference implementation on a Cycle container
[a, b, c] with focus on `a`: `KeyboardNavigationHandler.GetNext(a, Previous)` returns
`c`, this code returned `a`. The forward direction already wrapped correctly
(`c` -> `a`) because the Next branch happens to use the correct element there.
New test `Previous_Wraps_To_Last_Element_In_Cycle_Container` asserts the wrap target;
verified it fails (returns the focused element) with the one-line change reverted.
Full `Avalonia.Base.UnitTests`: 2998 tests, 0 failed (2986 passed, 12 skipped).
Co-Authored-By: Claude <noreply@anthropic.com>
---------
Co-authored-by: Claude <noreply@anthropic.com>
* test(grid): reproduce shared size groups ignoring assigned definitions
Definitions supplied through the ColumnDefinitions or RowDefinitions
setter are already in the collection when the grid claims it, so they
never pass through the collection-changed handler that joins them to the
parent tree. They never register with their shared size group, and the
definitions they replace never unregister from it.
* fix(grid): join assigned definition collections to the parent tree
DefinitionList.SetParent assigned each definition's Parent but never
called OnEnterParentTree, which only ran from the collection-changed
handler. Assigning Parent is not sufficient: OnEnterParentTree also sets
InheritanceParent, and a definition cannot read the inherited
PrivateSharedSizeScope that registers it with its group until that link
exists. Definitions supplied through the ColumnDefinitions setter - an
object initializer, a shared resource, or ColumnDefinitions="Auto,*" -
were therefore silently absent from their shared size group.
Enter and exit the parent tree from SetParent, and release the outgoing
collection when Grid swaps one in. Without that release the replaced
definitions stay registered with the group; nothing resets their measured
minimum any more, so they pin it at whatever they last contributed.
* test(grid): cover the definition ownership contract
Removing a definition leaves it holding its old Parent and its property
inheritance link, so it still reads the grid's shared size scope and can
re-register itself into a scope it has left. Also covers moving a
definition between grids, reassigning the same collection, and row
definitions, which the assignment fix reached but nothing exercised.
* refactor(grid): centralise definition parent-tree transitions
Definition ownership was implemented twice, and the two paths disagreed:
SetParent exited a definition and cleared its Parent, while removing one
from the collection called OnExitParentTree but left Parent set. Detach
was incomplete either way, since OnEnterParentTree establishes
InheritanceParent but OnExitParentTree never cleared it - so a removed
definition kept reading the grid's inherited PrivateSharedSizeScope, and
the grid kept it alive as an inheritance child.
Route every owner change through one transition that exits the old tree,
assigns Parent, and enters the new one, and clear InheritanceParent on
exit so detach mirrors attach.
---------
Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
* Force-mark closed window as no longer active if backend didn't do it for some reason
* [X11] Speculatively mark the active closed dialog parent as active window
* test(TextBox): reproduce stale undo history after binding update
TwoWay-bound TextBox instances retain prior user-edit snapshots when the binding source replaces the text, allowing undo to write values from a previous model context back into the current source. Cover the external replacement and the normal TwoWay source echo separately so a fix cannot clear valid user undo history after each edit.
* fix(TextBox): reset undo history for external text updates
Binding and direct property updates currently enter the same undo timeline as user edits, so a reused TwoWay-bound TextBox can write text from a previous model back into the current source. Track TextBox-initiated mutations through synchronous source notifications, preserve those edits in the undo timeline, and establish a fresh baseline for all external updates. MaskedTextBox routes its own edits through the same boundary so its existing undo behavior remains intact.
* fix(TextBox): distinguish edits from internal synchronization in undo history
Replace the boolean text-mutation flag with a three-state TextMutationKind
(ExternalReplacement / Edit / InternalSynchronization) so MaskedTextBox's
prompt-character reformatting on focus/blur and mask-provider refreshes no
longer create undo entries, while actual keyboard edits remain undoable.
* test(grid): reproduce shared size group shrink failure
Shared auto columns expand when grouped content becomes visible but keep the expanded width after that content is hidden. Cover the full zero, expanded, and shrunk layout sequence so the stale shared minimum cannot regress unnoticed.
* fix(grid): allow shared size groups to shrink
Shared auto definitions reused the previous group minimum while recomputing the next group minimum, so an expanded width became self-sustaining after content shrank. Aggregate each definition's intrinsic measured minimum instead, preserving the shared-size invariant and matching the canonical WPF algorithm.
* test(grid): reproduce shared size group stuck on cyclic measure path
A grid mixing an auto-column/star-row cell with a star-column/auto-row
cell measures through Grid's cyclic dependency path, which saves and
restores definition min sizes around the repeated measure. The saved
value is the effective min size, so the group minimum is folded into the
definition's own contribution and the group can never shrink below it.
* fix(grid): restore raw min sizes on the cyclic measure path
Grid.CacheMinSizes read DefinitionBase.MinSize, which already includes
the shared group's minimum, but ApplyCachedMinSizes writes it back
through SetMinSize, which assigns the definition's own _minSize. A
short-pole definition therefore adopted the group minimum as its own
intrinsic minimum, which reclassified it as a long pole on the next
validation. Long poles with a valid measure are never remeasured, so the
fabricated minimum became unreachable and pinned the group open.
Add DefinitionBase.RawMinSize, the read counterpart of SetMinSize, and
cache that instead so the save/restore pair round-trips the definition's
own contribution. Matches the WPF fix in dotnet/wpf#2270.
* test(textblock): cover fractional layout rounding
A wrapped TextBlock with a fractional line height must retain every line when its desired height lands exactly on a fractional-scale pixel boundary.
* fix(text): preserve lines at rounded fractional heights
TextLayout treated a floating-point accumulation error as a MaxHeight overflow. Use the established tolerant comparison so a line that exactly fits its rounded layout bounds is retained.
---------
Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
* feat: add ToolTip.ShouldUseOverlayLayer attached property
Add ShouldUseOverlayLayer attached property to ToolTip, which is bound
to Popup.ShouldUseOverlayLayer when the tooltip popup is created. This
allows per-control control over whether the tooltip popup uses the
overlay layer.
* docs: add proper XML docs for GetShouldUseOverlayLayer/SetShouldUseOverlayLayer
Replace <inheritdoc/> pointing to Popup.ShouldUseOverlayLayer (a property)
with proper <summary>, <param>, and <remarks> documentation for the
getter and setter methods.
Previously {Binding ^} was not parsed because ParseStart did not
recognize the ^ stream operator. Also, {Binding .^} failed because
ParseDot returned State.End immediately, preventing subsequent
operators.
Changes:
- ParseStart: recognize ^, emit EmptyExpressionNode + StreamNode
- ParseDot: return State.AfterMember instead of State.End, so .^ works
- Add grammar tests for ^ and .^ patterns