Struct AnnotatedRegionLayer 

pub struct AnnotatedRegionLayer { /* private fields */ }

A composited layer which annotates its children with a value. Pushing this layer to the tree is the common way of adding an annotation.

An annotation is an optional object of any type that, when attached with a layer, can be retrieved using AnyLayer::find or AnyLayer::find_all_annotations with a position. The search process is done recursively, controlled by a concept of being opaque to a type of annotation, explained in the document of Layer::find_annotations.

When an annotation search arrives, this layer defers the same search to each of this layer’s children, respecting their opacity. Then it adds this layer’s annotation if all of the following restrictions are met:

• The target type must be identical to the annotated type T.
• If size is provided, the target position must be contained within the rectangle formed by size and offset.

This layer is opaque to a type of annotation if any child is also opaque, or if opaque is true and the layer’s annotation is added.

Implementations

impl AnnotatedRegionLayer

pub fn new(app: &mut App, value: Rc<dyn Any>) -> Handle<AnnotatedRegionLayer>

Creates a new layer that annotates its children with value.

pub fn value(self: Handle<Self>, app: &App) -> &Rc<dyn Any>

The annotated object, which is added to the result if all restrictions are met.

pub fn size(self: Handle<Self>, app: &App) -> Option<Size>

The size of the annotated object.

If size is provided, then the annotation is found only if the target position is contained by the rectangle formed by size and offset. Otherwise no such restriction is applied, and clipping can only be done by the ancestor layers.

pub fn set_size(self: Handle<Self>, app: &mut App, value: Option<Size>)

See size.

pub fn offset(self: Handle<Self>, app: &App) -> Offset

The position of the annotated object.

The offset defaults to Offset::ZERO if not provided, and is ignored if size is not set.

The offset only offsets the clipping rectangle, and does not affect how the painting or annotation search is propagated to its children.

pub fn set_offset(self: Handle<Self>, app: &mut App, value: Offset)

See offset.

pub fn opaque(self: Handle<Self>, app: &App) -> bool

Whether the annotation of this layer should be opaque during an annotation search of type T, preventing siblings visually behind it from being searched.

If opaque is true, and this layer does add its annotation value, then the layer will always be opaque during the search.

If opaque is false, or if this layer does not add its annotation, then the opacity of this layer will be the one returned by the children, meaning that it will be opaque if any child is opaque.

The opaque defaults to false.

The opaque is effectively useless during AnyLayer::find (more specifically, Layer::find_annotations with only_first: true), since the search process then skips the remaining tree after finding the first annotation.

See also:

• Layer::find_annotations, which explains the concept of being opaque to a type of annotation as the return value.
• HitTestBehavior, which controls similar logic when hit-testing in the render tree.

pub fn set_opaque(self: Handle<Self>, app: &mut App, value: bool)

See opaque.

Trait Implementations

impl ContainerLayer for AnnotatedRegionLayer

fn container_layer_data(self: Handle<Self>, app: &App) -> &ContainerLayerData

Mixin field access.

fn container_layer_data_mut( self: Handle<Self>, app: &mut App, ) -> &mut ContainerLayerData

See container_layer_data.

const AS_OFFSET: Option<fn() -> &'static OffsetLayerVTable> = None

The offset table when this type extends OffsetLayer; container_layer_accessors!(offset) sets it. Dart’s layer is OffsetLayer.

fn as_container_layer(self: Handle<Self>) -> AnyContainerLayer

Dart’s implicit upcast of a concrete layer to ContainerLayer.

fn apply_transform( self: Handle<Self>, app: &App, child: Option<AnyLayer>, transform: &mut Matrix4, )

Applies the transform that would be applied when compositing the given child to the given matrix.

fn fire_composition_callbacks( self: Handle<Self>, app: &mut App, include_children: bool, )

ContainerLayer._fireCompositionCallbacks.

fn supports_rasterization(self: Handle<Self>, app: &App) -> bool

ContainerLayer.supportsRasterization.

fn dispose(self: Handle<Self>, app: &mut App)

ContainerLayer.dispose.

fn find_annotations( self: Handle<Self>, app: &App, result: &mut AnnotationSearch, local_position: Offset, only_first: bool, ) -> bool

ContainerLayer.findAnnotations.

fn attach(self: Handle<Self>, app: &mut App, owner: HandleId)

ContainerLayer.attach.

fn detach(self: Handle<Self>, app: &mut App)

ContainerLayer.detach.

fn redepth_children(self: Handle<Self>, app: &mut App)

ContainerLayer.redepthChildren.

fn add_to_scene(self: Handle<Self>, app: &mut App, builder: &mut SceneBuilder)

ContainerLayer.addToScene.

impl Layer for AnnotatedRegionLayer

fn find_annotations( self: Handle<Self>, app: &App, result: &mut AnnotationSearch, local_position: Offset, only_first: bool, ) -> bool

Searches the subtree for annotations of the searched type at the location local_position, then adds the annotation value if applicable.

This method always searches its children, and if any child returns true, the remaining children are skipped. Regardless of what the children return, this method then adds this layer’s annotation if all of the following restrictions are met:

• The target type must be identical to the annotated type T.
• If size is provided, the target position must be contained within the rectangle formed by size and offset.

This search process respects only_first, meaning that when only_first is true, the search will stop when it finds the first annotation from the children, and the layer’s own annotation is checked only when none is given by the children.

The return value is true if any child returns true, or if opaque is true and the layer’s annotation is added.

For explanation of layer annotations, parameters and return value, refer to Layer::find_annotations.

const AS_CONTAINER: Option<fn() -> &'static ContainerLayerVTable>

The container table when this type extends ContainerLayer; layer_accessors!(container) sets it. Dart’s layer is ContainerLayer.

fn layer_data(self: Handle<Self>, app: &App) -> &LayerData

Dart’s base-class fields, held under the field layer ([layer_accessors!]).

fn layer_data_mut(self: Handle<Self>, app: &mut App) -> &mut LayerData

See layer_data.

fn supports_rasterization(self: Handle<Self>, app: &App) -> bool

Whether or not this layer, or any child layers, can be rasterized with Scene.toImage.

fn dispose(self: Handle<Self>, app: &mut App)

Clears any retained resources that this layer holds.

fn attach(self: Handle<Self>, app: &mut App, owner: HandleId)

Mark this layer as attached to the given owner.

fn detach(self: Handle<Self>, app: &mut App)

Mark this layer as detached from its owner.

fn redepth_children(self: Handle<Self>, app: &mut App)

Adjust the depth of this node’s children, if any.

fn add_to_scene(self: Handle<Self>, app: &mut App, builder: &mut SceneBuilder)

Override this method to upload this layer to the engine.

fn fire_composition_callbacks( self: Handle<Self>, app: &mut App, include_children: bool, )

Dart’s _fireCompositionCallbacks; ContainerLayer recurses into its children.

fn describe_clip_bounds(self: Handle<Self>, app: &App) -> Option<Rect>

Describes the clip that would be applied to contents of this layer, if any.

fn always_needs_add_to_scene(self: Handle<Self>, app: &App) -> bool

Subclasses may override this to true to disable retained rendering.