Package-level declarations

Opts a SwingModifier.Node subtype into reading a CompositionLocal the node's component was declared under, through currentValueOf. The counterpart of AndroidX CompositionLocalConsumerModifierNode.

Mirrors the value a widget property currently holds - a property the widget can change on its own, independently of the composition's declaration - and carries a change the composition has not answered for to the scope that declares it.

A SwingModifier.Node notified through onObservedReadsChanged when a value read in observeReads changes.

The receiver reconcileWithChildren hands its block, standing for the node without exposing it.

The node a Swing composition stores for one declared component, read off a node group of its CompositionData:

A component that is told the SwingComponentNodes holding it while they are attached to a composition: a node a composition declares for it, and the node a setContent call on it roots its content at. Both can be attached at once, and the component is told about each one separately.

Receiver of a SwingNode update block. The typed component T is this in its operations.

This node, typed by component, which it holds. A SwingComponentNodeListener component calls it with this to type the node it is told, so the callbacks it records under that node receive the component without a cast.

The value local resolves to in the composition scope where this node's component was declared. Answers for every CompositionLocal in scope there.

Declares value onto a widget property the user can also change, keeping mirror in sync with it.

Declares value onto a widget property whose write is a transition rather than an assignment: write is handed what the widget holds alongside what is declared, so it can write only the part that differs and leave what the rest of the value anchors standing - the caret inside a document, above all. The held value is the one the settlement has already read, so the write costs no second read.

Configures a component its parent already built and keeps, such as a JScrollPane's scroll bars or a JLayer's glass pane, the way SwingNode configures a component its own factory builds.

Container variant of ExistingSwingNode that composes content into the claimed container.

Invalidates layout on the Event Dispatch Thread. When the component tree lock is held, invalidation happens immediately and revalidation runs on the next event-queue turn; otherwise revalidation runs immediately. Pending revalidation is canceled when this node detaches: when it is reused, deactivated, released or moved to another composition, or when its composition is disposed. Does nothing while this node is not attached, which includes a root whose composition is disposed.

Emits one menu node into the surrounding MenuApplier composition: factory builds the backing Swing widget, update maps composition state onto it, and content supplies any nested menu items (empty for a leaf such as a single item or separator).

Runs block, recording its reads under this node; after one of them changes, calls ObserverModifierNode.onObservedReadsChanged once, while the node is attached.

Runs block, recording its reads under this node and onChanged; after one of them changes, calls onChanged with this node once, while it is attached. Reads are grouped by the onChanged instance, as SnapshotStateObserver.observeReads groups them: pass the same instance on every call, and use one instance per set of reads that must not drop another's.

Runs block, recording its reads under this node, as SwingModifier.Node.observeReads does for a modifier node; onChanged receives this node, on the Event Dispatch Thread.

Reconciles block against this node's children, at the end of the change pass rather than here.

Remembers the MirrorState a component settles a declaration through, seeded with initial - what the widget will actually hold on the first pass, which is not always what the composition declares for it: a ToolBar is always docked when it is built, whatever floating its first declaration asks for, so its seed is false rather than the declaration.

Carries to the caller a change the widget published on one channel and reports on another: onChanged runs and the settling pass follows it, as in MirrorState.report, but the value itself was mirrored through MirrorState.observed when the earlier channel carried it.

Runs action on the Event Dispatch Thread. Calls made while this node's component tree lock is held are coalesced by node and callback identity until the next event-queue turn; reuse the same callback instance to coalesce repeated requests. Calls made without the lock run immediately and cancel a matching queued call. Detaching this node or disposing its composition drops its pending calls.

Runs action on the Event Dispatch Thread, as SwingModifier.Node.requestAfterValidation does for a modifier node; action receives this node.

Declares a leaf or container Swing node in the composition.

Container variant of SwingNode that hosts composable content as children.