Struct ResolvedElement 

pub struct ResolvedElement {

    pub id: ElementId,
    pub kind: ElementKind,
    pub bounds: BoundsSet,
    pub collidable: bool,
    pub shape: Shape,
    pub transform: Transform,
    pub style: ComputedStyle,
    pub text: Option<String>,
    pub text_layout: Option<TextLayout>,
    pub asset: Option<String>,
    pub image_placement: Option<ImagePlacement>,
    pub table: Option<ResolvedTableFragment>,
    pub layer: String,
    pub z_index: i32,
    pub sequence: usize,
    pub provenance: Provenance,
    pub layout_trace: LayoutTrace,
}

Fully resolved exporter-facing element.

Fields

id: ElementId

Stable source ID.

kind: ElementKind

Element kind.

bounds: BoundsSet

Distinct resolved geometry boxes.

collidable: bool

Whether this element participates in collision masks and preflight.

shape: Shape

Collision/vector shape.

transform: Transform

Transform already accounted for in collision bounds.

style: ComputedStyle

Computed style.

text: Option<String>

Literal/bound text.

text_layout: Option<TextLayout>

Shaped glyph layout when this is text.

asset: Option<String>

Explicit asset name.

image_placement: Option<ImagePlacement>

Exporter-ready image crop and destination geometry.

table: Option<ResolvedTableFragment>

Exporter-ready table fragment geometry and shaped cell text.

layer: String

Visual layer.

z_index: i32

Visual z index.

sequence: usize

Stable source order.

provenance: Provenance

Source and mutation provenance.

layout_trace: LayoutTrace

Bound source geometry and placement decisions.

Trait Implementations

impl Clone for ResolvedElement

fn clone(&self) -> ResolvedElement

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ResolvedElement

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ResolvedElement

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ResolvedElement

impl PartialEq for ResolvedElement

fn eq(&self, other: &ResolvedElement) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for ResolvedElement

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ResolvedElement