Struct TextLayout

pub struct TextLayout {
    pub justify: JustifyText,
    pub linebreak: LineBreak,
}

Component with text format settings for a block of text.

A block of text is composed of text spans, which each have a separate string value and TextFont. Text spans associated with a text block are collected into ComputedTextBlock for layout, and then inserted to TextLayoutInfo for rendering.

See Text2d for the core component of 2d text, and Text in bevy_ui for UI text.

Fields

justify: JustifyText

The text’s internal alignment. Should not affect its position within a container.

linebreak: LineBreak

How the text should linebreak when running out of the bounds determined by max_size.

Implementations

impl TextLayout

pub const fn new(justify: JustifyText, linebreak: LineBreak) -> TextLayout

Makes a new TextLayout.

Examples found in repository

examples/testbed/ui.rs (line 376)

    pub fn setup(mut commands: Commands) {
        commands.spawn((Camera2d, StateScoped(super::Scene::TextWrap)));

        let root = commands
            .spawn((
                Node {
                    flex_direction: FlexDirection::Column,
                    width: Val::Px(200.),
                    height: Val::Percent(100.),
                    overflow: Overflow::clip_x(),
                    ..default()
                },
                BackgroundColor(Color::BLACK),
                StateScoped(super::Scene::TextWrap),
            ))
            .id();

        for linebreak in [
            LineBreak::AnyCharacter,
            LineBreak::WordBoundary,
            LineBreak::WordOrCharacter,
            LineBreak::NoWrap,
        ] {
            let messages = [
                "Lorem ipsum dolor sit amet, consectetur adipiscing elit.".to_string(),
                "pneumonoultramicroscopicsilicovolcanoconiosis".to_string(),
            ];

            for (j, message) in messages.into_iter().enumerate() {
                commands.entity(root).with_child((
                    Text(message.clone()),
                    TextLayout::new(JustifyText::Left, linebreak),
                    BackgroundColor(Color::srgb(0.8 - j as f32 * 0.3, 0., 0.)),
                ));
            }
        }
    }

examples/ui/text_wrap_debug.rs (line 120)

fn spawn(mut commands: Commands, asset_server: Res<AssetServer>) {
    commands.spawn(Camera2d);

    let text_font = TextFont {
        font: asset_server.load("fonts/FiraSans-Bold.ttf"),
        font_size: 12.0,
        ..default()
    };

    let root = commands
        .spawn((
            Node {
                width: Val::Percent(100.),
                height: Val::Percent(100.),
                flex_direction: FlexDirection::Column,
                ..default()
            },
            BackgroundColor(Color::BLACK),
        ))
        .id();

    for linebreak in [
        LineBreak::AnyCharacter,
        LineBreak::WordBoundary,
        LineBreak::WordOrCharacter,
        LineBreak::NoWrap,
    ] {
        let row_id = commands
            .spawn(Node {
                flex_direction: FlexDirection::Row,
                justify_content: JustifyContent::SpaceAround,
                align_items: AlignItems::Center,
                width: Val::Percent(100.),
                height: Val::Percent(50.),
                ..default()
            })
            .id();

        let justifications = vec![
            JustifyContent::Center,
            JustifyContent::FlexStart,
            JustifyContent::FlexEnd,
            JustifyContent::SpaceAround,
            JustifyContent::SpaceBetween,
            JustifyContent::SpaceEvenly,
        ];

        for (i, justification) in justifications.into_iter().enumerate() {
            let c = 0.3 + i as f32 * 0.1;
            let column_id = commands
                .spawn((
                    Node {
                        justify_content: justification,
                        flex_direction: FlexDirection::Column,
                        width: Val::Percent(16.),
                        height: Val::Percent(95.),
                        overflow: Overflow::clip_x(),
                        ..default()
                    },
                    BackgroundColor(Color::srgb(0.5, c, 1.0 - c)),
                ))
                .id();

            let messages = [
                format!("JustifyContent::{justification:?}"),
                format!("LineBreakOn::{linebreak:?}"),
                "Line 1\nLine 2".to_string(),
                "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Maecenas auctor, nunc ac faucibus fringilla.".to_string(),
                "pneumonoultramicroscopicsilicovolcanoconiosis".to_string()
            ];

            for (j, message) in messages.into_iter().enumerate() {
                commands.entity(column_id).with_child((
                    Text(message.clone()),
                    text_font.clone(),
                    TextLayout::new(JustifyText::Left, linebreak),
                    BackgroundColor(Color::srgb(0.8 - j as f32 * 0.2, 0., 0.)),
                ));
            }
            commands.entity(row_id).add_child(column_id);
        }
        commands.entity(root).add_child(row_id);
    }
}

examples/2d/text2d.rs (line 84)

fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
    let font = asset_server.load("fonts/FiraSans-Bold.ttf");
    let text_font = TextFont {
        font: font.clone(),
        font_size: 50.0,
        ..default()
    };
    let text_justification = JustifyText::Center;
    commands.spawn(Camera2d);
    // Demonstrate changing translation
    commands.spawn((
        Text2d::new("translation"),
        text_font.clone(),
        TextLayout::new_with_justify(text_justification),
        AnimateTranslation,
    ));
    // Demonstrate changing rotation
    commands.spawn((
        Text2d::new("rotation"),
        text_font.clone(),
        TextLayout::new_with_justify(text_justification),
        AnimateRotation,
    ));
    // Demonstrate changing scale
    commands.spawn((
        Text2d::new("scale"),
        text_font,
        TextLayout::new_with_justify(text_justification),
        Transform::from_translation(Vec3::new(400.0, 0.0, 0.0)),
        AnimateScale,
    ));
    // Demonstrate text wrapping
    let slightly_smaller_text_font = TextFont {
        font,
        font_size: 35.0,
        ..default()
    };
    let box_size = Vec2::new(300.0, 200.0);
    let box_position = Vec2::new(0.0, -250.0);
    commands
        .spawn((
            Sprite::from_color(Color::srgb(0.25, 0.25, 0.55), box_size),
            Transform::from_translation(box_position.extend(0.0)),
        ))
        .with_children(|builder| {
            builder.spawn((
                Text2d::new("this text wraps in the box\n(Unicode linebreaks)"),
                slightly_smaller_text_font.clone(),
                TextLayout::new(JustifyText::Left, LineBreak::WordBoundary),
                // Wrap text in the rectangle
                TextBounds::from(box_size),
                // Ensure the text is drawn on top of the box
                Transform::from_translation(Vec3::Z),
            ));
        });

    let other_box_size = Vec2::new(300.0, 200.0);
    let other_box_position = Vec2::new(320.0, -250.0);
    commands
        .spawn((
            Sprite::from_color(Color::srgb(0.25, 0.25, 0.55), other_box_size),
            Transform::from_translation(other_box_position.extend(0.0)),
        ))
        .with_children(|builder| {
            builder.spawn((
                Text2d::new("this text wraps in the box\n(AnyCharacter linebreaks)"),
                slightly_smaller_text_font.clone(),
                TextLayout::new(JustifyText::Left, LineBreak::AnyCharacter),
                // Wrap text in the rectangle
                TextBounds::from(other_box_size),
                // Ensure the text is drawn on top of the box
                Transform::from_translation(Vec3::Z),
            ));
        });

    // Demonstrate font smoothing off
    commands.spawn((
        Text2d::new("This text has\nFontSmoothing::None\nAnd JustifyText::Center"),
        slightly_smaller_text_font
            .clone()
            .with_font_smoothing(FontSmoothing::None),
        TextLayout::new_with_justify(JustifyText::Center),
        Transform::from_translation(Vec3::new(-400.0, -250.0, 0.0)),
    ));

    commands
        .spawn((
            Sprite {
                color: Color::Srgba(LIGHT_CYAN),
                custom_size: Some(Vec2::new(10., 10.)),
                ..Default::default()
            },
            Transform::from_translation(250. * Vec3::Y),
        ))
        .with_children(|commands| {
            for (text_anchor, color) in [
                (Anchor::TopLeft, Color::Srgba(LIGHT_SALMON)),
                (Anchor::TopRight, Color::Srgba(LIGHT_GREEN)),
                (Anchor::BottomRight, Color::Srgba(LIGHT_BLUE)),
                (Anchor::BottomLeft, Color::Srgba(LIGHT_YELLOW)),
            ] {
                commands
                    .spawn((
                        Text2d::new(" Anchor".to_string()),
                        slightly_smaller_text_font.clone(),
                        text_anchor,
                    ))
                    .with_child((
                        TextSpan("::".to_string()),
                        slightly_smaller_text_font.clone(),
                        TextColor(LIGHT_GREY.into()),
                    ))
                    .with_child((
                        TextSpan(format!("{text_anchor:?} ")),
                        slightly_smaller_text_font.clone(),
                        TextColor(color),
                    ));
            }
        });
}

pub fn new_with_justify(justify: JustifyText) -> TextLayout

Makes a new TextLayout with the specified JustifyText.

Examples found in repository

examples/async_tasks/external_source_external_thread.rs (line 57)

fn spawn_text(mut commands: Commands, mut reader: EventReader<StreamEvent>) {
    for (per_frame, event) in reader.read().enumerate() {
        commands.spawn((
            Text2d::new(event.0.to_string()),
            TextLayout::new_with_justify(JustifyText::Center),
            Transform::from_xyz(per_frame as f32 * 100.0, 300.0, 0.0),
        ));
    }
}

examples/2d/texture_atlas.rs (line 282)

fn create_label(
    commands: &mut Commands,
    translation: (f32, f32, f32),
    text: &str,
    text_style: TextFont,
) {
    commands.spawn((
        Text2d::new(text),
        text_style,
        TextLayout::new_with_justify(JustifyText::Center),
        Transform {
            translation: Vec3::new(translation.0, translation.1, translation.2),
            ..default()
        },
    ));
}

examples/ecs/one_shot_systems.rs (line 97)

fn setup_ui(mut commands: Commands) {
    commands.spawn(Camera2d);
    commands
        .spawn((
            Text::default(),
            TextLayout::new_with_justify(JustifyText::Center),
            Node {
                align_self: AlignSelf::Center,
                justify_self: JustifySelf::Center,
                ..default()
            },
        ))
        .with_children(|p| {
            p.spawn(TextSpan::new("Press A or B to trigger a one-shot system\n"));
            p.spawn(TextSpan::new("Last Triggered: "));
            p.spawn((
                TextSpan::new("-"),
                TextColor(bevy::color::palettes::css::ORANGE.into()),
            ));
        });
}

examples/3d/tonemapping.rs (line 180)

fn setup_image_viewer_scene(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
    camera_transform: Res<CameraTransform>,
) {
    let mut transform = camera_transform.0;
    transform.translation += *transform.forward();

    // exr/hdr viewer (exr requires enabling bevy feature)
    commands.spawn((
        Mesh3d(meshes.add(Rectangle::default())),
        MeshMaterial3d(materials.add(StandardMaterial {
            base_color_texture: None,
            unlit: true,
            ..default()
        })),
        transform,
        Visibility::Hidden,
        SceneNumber(3),
        HDRViewer,
    ));

    commands.spawn((
        Text::new("Drag and drop an HDR or EXR file"),
        TextFont {
            font_size: 36.0,
            ..default()
        },
        TextColor(Color::BLACK),
        TextLayout::new_with_justify(JustifyText::Center),
        Node {
            align_self: AlignSelf::Center,
            margin: UiRect::all(Val::Auto),
            ..default()
        },
        SceneNumber(3),
        Visibility::Hidden,
    ));
}

examples/math/render_primitives.rs (line 382)

fn setup_text(mut commands: Commands, cameras: Query<(Entity, &Camera)>) {
    let active_camera = cameras
        .iter()
        .find_map(|(entity, camera)| camera.is_active.then_some(entity))
        .expect("run condition ensures existence");
    commands.spawn((
        HeaderNode,
        Node {
            justify_self: JustifySelf::Center,
            top: Val::Px(5.0),
            ..Default::default()
        },
        UiTargetCamera(active_camera),
        children![(
            Text::default(),
            HeaderText,
            TextLayout::new_with_justify(JustifyText::Center),
            children![
                TextSpan::new("Primitive: "),
                TextSpan(format!("{text}", text = PrimitiveSelected::default())),
                TextSpan::new("\n\n"),
                TextSpan::new(
                    "Press 'C' to switch between 2D and 3D mode\n\
                    Press 'Up' or 'Down' to switch to the next/previous primitive",
                ),
                TextSpan::new("\n\n"),
                TextSpan::new("(If nothing is displayed, there's no rendering support yet)",),
            ]
        )],
    ));
}

examples/ui/size_constraints.rs (line 254)

fn spawn_button(
    parent: &mut ChildSpawnerCommands,
    constraint: Constraint,
    action: ButtonValue,
    label: String,
    text_style: (TextFont, TextColor),
    active: bool,
) {
    parent
        .spawn((
            Button,
            Node {
                align_items: AlignItems::Center,
                justify_content: JustifyContent::Center,
                border: UiRect::all(Val::Px(2.)),
                margin: UiRect::horizontal(Val::Px(2.)),
                ..Default::default()
            },
            BorderColor(if active {
                ACTIVE_BORDER_COLOR
            } else {
                INACTIVE_BORDER_COLOR
            }),
            constraint,
            action,
        ))
        .with_children(|parent| {
            parent
                .spawn((
                    Node {
                        width: Val::Px(100.),
                        justify_content: JustifyContent::Center,
                        ..default()
                    },
                    BackgroundColor(if active {
                        ACTIVE_INNER_COLOR
                    } else {
                        INACTIVE_INNER_COLOR
                    }),
                ))
                .with_child((
                    Text::new(label),
                    text_style.0,
                    TextColor(if active {
                        ACTIVE_TEXT_COLOR
                    } else {
                        UNHOVERED_TEXT_COLOR
                    }),
                    TextLayout::new_with_justify(JustifyText::Center),
                ));
        });
}

Additional examples can be found in:

• examples/stress_tests/many_text2d.rs
• examples/testbed/2d.rs
• examples/animation/animated_ui.rs
• examples/time/virtual_time.rs
• examples/animation/animation_graph.rs
• examples/2d/sprite_slice.rs
• examples/ui/text.rs
• examples/ui/display_and_visibility.rs
• examples/2d/text2d.rs
• examples/animation/animation_masks.rs
• examples/2d/sprite_scale.rs
• examples/ui/text_debug.rs

pub fn new_with_linebreak(linebreak: LineBreak) -> TextLayout

Makes a new TextLayout with the specified LineBreak.

pub fn new_with_no_wrap() -> TextLayout

Makes a new TextLayout with soft wrapping disabled. Hard wrapping, where text contains an explicit linebreak such as the escape sequence \n, will still occur.

pub const fn with_justify(self, justify: JustifyText) -> TextLayout

Returns this TextLayout with the specified JustifyText.

pub const fn with_linebreak(self, linebreak: LineBreak) -> TextLayout

Returns this TextLayout with the specified LineBreak.

pub const fn with_no_wrap(self) -> TextLayout

Returns this TextLayout with soft wrapping disabled. Hard wrapping, where text contains an explicit linebreak such as the escape sequence \n, will still occur.

Examples found in repository

examples/3d/blend_modes.rs (line 209)

fn setup(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
    asset_server: Res<AssetServer>,
) {
    let base_color = Color::srgb(0.9, 0.2, 0.3);
    let icosphere_mesh = meshes.add(Sphere::new(0.9).mesh().ico(7).unwrap());

    // Opaque
    let opaque = commands
        .spawn((
            Mesh3d(icosphere_mesh.clone()),
            MeshMaterial3d(materials.add(StandardMaterial {
                base_color,
                alpha_mode: AlphaMode::Opaque,
                ..default()
            })),
            Transform::from_xyz(-4.0, 0.0, 0.0),
            ExampleControls {
                unlit: true,
                color: true,
            },
        ))
        .id();

    // Blend
    let blend = commands
        .spawn((
            Mesh3d(icosphere_mesh.clone()),
            MeshMaterial3d(materials.add(StandardMaterial {
                base_color,
                alpha_mode: AlphaMode::Blend,
                ..default()
            })),
            Transform::from_xyz(-2.0, 0.0, 0.0),
            ExampleControls {
                unlit: true,
                color: true,
            },
        ))
        .id();

    // Premultiplied
    let premultiplied = commands
        .spawn((
            Mesh3d(icosphere_mesh.clone()),
            MeshMaterial3d(materials.add(StandardMaterial {
                base_color,
                alpha_mode: AlphaMode::Premultiplied,
                ..default()
            })),
            Transform::from_xyz(0.0, 0.0, 0.0),
            ExampleControls {
                unlit: true,
                color: true,
            },
        ))
        .id();

    // Add
    let add = commands
        .spawn((
            Mesh3d(icosphere_mesh.clone()),
            MeshMaterial3d(materials.add(StandardMaterial {
                base_color,
                alpha_mode: AlphaMode::Add,
                ..default()
            })),
            Transform::from_xyz(2.0, 0.0, 0.0),
            ExampleControls {
                unlit: true,
                color: true,
            },
        ))
        .id();

    // Multiply
    let multiply = commands
        .spawn((
            Mesh3d(icosphere_mesh),
            MeshMaterial3d(materials.add(StandardMaterial {
                base_color,
                alpha_mode: AlphaMode::Multiply,
                ..default()
            })),
            Transform::from_xyz(4.0, 0.0, 0.0),
            ExampleControls {
                unlit: true,
                color: true,
            },
        ))
        .id();

    // Chessboard Plane
    let black_material = materials.add(Color::BLACK);
    let white_material = materials.add(Color::WHITE);

    let plane_mesh = meshes.add(Plane3d::default().mesh().size(2.0, 2.0));

    for x in -3..4 {
        for z in -3..4 {
            commands.spawn((
                Mesh3d(plane_mesh.clone()),
                MeshMaterial3d(if (x + z) % 2 == 0 {
                    black_material.clone()
                } else {
                    white_material.clone()
                }),
                Transform::from_xyz(x as f32 * 2.0, -1.0, z as f32 * 2.0),
                ExampleControls {
                    unlit: false,
                    color: true,
                },
            ));
        }
    }

    // Light
    commands.spawn((PointLight::default(), Transform::from_xyz(4.0, 8.0, 4.0)));

    // Camera
    commands.spawn((
        Camera3d::default(),
        Transform::from_xyz(0.0, 2.5, 10.0).looking_at(Vec3::ZERO, Vec3::Y),
        // Unfortunately, MSAA and HDR are not supported simultaneously under WebGL.
        // Since this example uses HDR, we must disable MSAA for Wasm builds, at least
        // until WebGPU is ready and no longer behind a feature flag in Web browsers.
        #[cfg(target_arch = "wasm32")]
        Msaa::Off,
    ));

    // Controls Text

    // We need the full version of this font so we can use box drawing characters.
    let text_style = TextFont {
        font: asset_server.load("fonts/FiraMono-Medium.ttf"),
        ..default()
    };

    let label_text_style = (text_style.clone(), TextColor(ORANGE.into()));

    commands.spawn((Text::new("Up / Down — Increase / Decrease Alpha\nLeft / Right — Rotate Camera\nH - Toggle HDR\nSpacebar — Toggle Unlit\nC — Randomize Colors"),
            text_style.clone(),
        Node {
            position_type: PositionType::Absolute,
            top: Val::Px(12.0),
            left: Val::Px(12.0),
            ..default()
        })
    );

    commands.spawn((
        Text::default(),
        text_style,
        Node {
            position_type: PositionType::Absolute,
            top: Val::Px(12.0),
            right: Val::Px(12.0),
            ..default()
        },
        ExampleDisplay,
    ));

    let mut label = |entity: Entity, label: &str| {
        commands
            .spawn((
                Node {
                    position_type: PositionType::Absolute,
                    ..default()
                },
                ExampleLabel { entity },
            ))
            .with_children(|parent| {
                parent.spawn((
                    Text::new(label),
                    label_text_style.clone(),
                    Node {
                        position_type: PositionType::Absolute,
                        bottom: Val::ZERO,
                        ..default()
                    },
                    TextLayout::default().with_no_wrap(),
                ));
            });
    };

    label(opaque, "┌─ Opaque\n│\n│\n│\n│");
    label(blend, "┌─ Blend\n│\n│\n│");
    label(premultiplied, "┌─ Premultiplied\n│\n│");
    label(add, "┌─ Add\n│");
    label(multiply, "┌─ Multiply");
}

Trait Implementations

impl Clone for TextLayout

fn clone(&self) -> TextLayout

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Component for TextLayout

where TextLayout: Send + Sync + 'static,

Required Components: ComputedTextBlock, TextLayoutInfo.

A component’s Required Components are inserted whenever it is inserted. Note that this will also insert the required components of the required components, recursively, in depth-first order.

const STORAGE_TYPE: StorageType = bevy_ecs::component::StorageType::Table

A constant indicating the storage type used for this component.

type Mutability = Mutable

A marker type to assist Bevy with determining if this component is mutable, or immutable. Mutable components will have [Component<Mutability = Mutable>], while immutable components will instead have [Component<Mutability = Immutable>].

fn register_required_components( requiree: ComponentId, components: &mut ComponentsRegistrator<'_>, required_components: &mut RequiredComponents, inheritance_depth: u16, recursion_check_stack: &mut Vec<ComponentId>, )

Registers required components.

fn clone_behavior() -> ComponentCloneBehavior

Called when registering this component, allowing to override clone function (or disable cloning altogether) for this component.

fn register_component_hooks(hooks: &mut ComponentHooks)

👎Deprecated since 0.16.0: Use the individual hook methods instead (e.g., Component::on_add, etc.)

Called when registering this component, allowing mutable access to its ComponentHooks.

fn on_add() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_add ComponentHook for this Component if one is defined.

fn on_insert() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_insert ComponentHook for this Component if one is defined.

fn on_replace() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_replace ComponentHook for this Component if one is defined.

fn on_remove() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_remove ComponentHook for this Component if one is defined.

fn on_despawn() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_despawn ComponentHook for this Component if one is defined.

fn map_entities<E>(_this: &mut Self, _mapper: &mut E)

where E: EntityMapper,

Maps the entities on this component using the given EntityMapper. This is used to remap entities in contexts like scenes and entity cloning. When deriving Component, this is populated by annotating fields containing entities with #[entities]

impl Debug for TextLayout

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

Formats the value using the given formatter.

impl Default for TextLayout

fn default() -> TextLayout

Returns the “default value” for a type.

impl FromArg for &'static TextLayout

where TextLayout: Any + Send + Sync, JustifyText: FromReflect + TypePath + MaybeTyped + RegisterForReflection, LineBreak: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

type This<'from_arg> = &'from_arg TextLayout

The type to convert into.

fn from_arg( arg: Arg<'_>, ) -> Result<<&'static TextLayout as FromArg>::This<'_>, ArgError>

Creates an item from an argument.

impl FromArg for &'static mut TextLayout

where TextLayout: Any + Send + Sync, JustifyText: FromReflect + TypePath + MaybeTyped + RegisterForReflection, LineBreak: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

type This<'from_arg> = &'from_arg mut TextLayout

The type to convert into.

fn from_arg( arg: Arg<'_>, ) -> Result<<&'static mut TextLayout as FromArg>::This<'_>, ArgError>

Creates an item from an argument.

impl FromArg for TextLayout

where TextLayout: Any + Send + Sync, JustifyText: FromReflect + TypePath + MaybeTyped + RegisterForReflection, LineBreak: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

type This<'from_arg> = TextLayout

The type to convert into.

fn from_arg(arg: Arg<'_>) -> Result<<TextLayout as FromArg>::This<'_>, ArgError>

Creates an item from an argument.

impl FromReflect for TextLayout

where TextLayout: Any + Send + Sync, JustifyText: FromReflect + TypePath + MaybeTyped + RegisterForReflection, LineBreak: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn from_reflect(reflect: &(dyn PartialReflect + 'static)) -> Option<TextLayout>

Constructs a concrete instance of Self from a reflected value.

fn take_from_reflect( reflect: Box<dyn PartialReflect>, ) -> Result<Self, Box<dyn PartialReflect>>

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails.

impl GetOwnership for &TextLayout

where TextLayout: Any + Send + Sync, JustifyText: FromReflect + TypePath + MaybeTyped + RegisterForReflection, LineBreak: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn ownership() -> Ownership

Returns the ownership of Self.

impl GetOwnership for &mut TextLayout

where TextLayout: Any + Send + Sync, JustifyText: FromReflect + TypePath + MaybeTyped + RegisterForReflection, LineBreak: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn ownership() -> Ownership

Returns the ownership of Self.

impl GetOwnership for TextLayout

where TextLayout: Any + Send + Sync, JustifyText: FromReflect + TypePath + MaybeTyped + RegisterForReflection, LineBreak: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn ownership() -> Ownership

Returns the ownership of Self.

impl GetTypeRegistration for TextLayout

where TextLayout: Any + Send + Sync, JustifyText: FromReflect + TypePath + MaybeTyped + RegisterForReflection, LineBreak: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn get_type_registration() -> TypeRegistration

Returns the default TypeRegistration for this type.

fn register_type_dependencies(registry: &mut TypeRegistry)

Registers other types needed by this type.

impl IntoReturn for &TextLayout

where TextLayout: Any + Send + Sync, JustifyText: FromReflect + TypePath + MaybeTyped + RegisterForReflection, LineBreak: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn into_return<'into_return>(self) -> Return<'into_return>

where &TextLayout: 'into_return,

Converts Self into a Return value.

impl IntoReturn for &mut TextLayout

where TextLayout: Any + Send + Sync, JustifyText: FromReflect + TypePath + MaybeTyped + RegisterForReflection, LineBreak: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn into_return<'into_return>(self) -> Return<'into_return>

where &mut TextLayout: 'into_return,

Converts Self into a Return value.

impl IntoReturn for TextLayout

where TextLayout: Any + Send + Sync, JustifyText: FromReflect + TypePath + MaybeTyped + RegisterForReflection, LineBreak: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn into_return<'into_return>(self) -> Return<'into_return>

where TextLayout: 'into_return,

Converts Self into a Return value.

impl PartialReflect for TextLayout

where TextLayout: Any + Send + Sync, JustifyText: FromReflect + TypePath + MaybeTyped + RegisterForReflection, LineBreak: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

Returns the TypeInfo of the type represented by this value.

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

Tries to apply a reflected value to this value.

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type.

fn reflect_ref(&self) -> ReflectRef<'_>

Returns an immutable enumeration of “kinds” of type.

fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<TextLayout>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn try_into_reflect( self: Box<TextLayout>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

Attempts to cast this type to a boxed, fully-reflected value.

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

Attempts to cast this type to a fully-reflected value.

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

Attempts to cast this type to a mutable, fully-reflected value.

fn into_partial_reflect(self: Box<TextLayout>) -> Box<dyn PartialReflect>

Casts this type to a boxed, reflected value.

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

Casts this type to a reflected value.

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

Casts this type to a mutable, reflected value.

fn reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>

Returns a “partial equality” comparison result.

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

Debug formatter for the value.

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

Attempts to clone Self using reflection.

fn apply(&mut self, value: &(dyn PartialReflect + 'static))

Applies a reflected value to this value.

fn clone_value(&self) -> Box<dyn PartialReflect>

👎Deprecated since 0.16.0: to clone reflected values, prefer using reflect_clone. To convert reflected values to dynamic ones, use to_dynamic.

Clones Self into its dynamic representation.

fn to_dynamic(&self) -> Box<dyn PartialReflect>

Converts this reflected value into its dynamic representation based on its kind.

fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type).

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl Reflect for TextLayout

where TextLayout: Any + Send + Sync, JustifyText: FromReflect + TypePath + MaybeTyped + RegisterForReflection, LineBreak: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn into_any(self: Box<TextLayout>) -> Box<dyn Any>

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &(dyn Any + 'static)

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Returns the value as a &mut dyn Any.

fn into_reflect(self: Box<TextLayout>) -> Box<dyn Reflect>

Casts this type to a boxed, fully-reflected value.

fn as_reflect(&self) -> &(dyn Reflect + 'static)

Casts this type to a fully-reflected value.

fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

Casts this type to a mutable, fully-reflected value.

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

Performs a type-checked assignment of a reflected value to this value.

impl Struct for TextLayout

where TextLayout: Any + Send + Sync, JustifyText: FromReflect + TypePath + MaybeTyped + RegisterForReflection, LineBreak: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn field(&self, name: &str) -> Option<&(dyn PartialReflect + 'static)>

Returns a reference to the value of the field named name as a &dyn PartialReflect.

fn field_mut( &mut self, name: &str, ) -> Option<&mut (dyn PartialReflect + 'static)>

Returns a mutable reference to the value of the field named name as a &mut dyn PartialReflect.

fn field_at(&self, index: usize) -> Option<&(dyn PartialReflect + 'static)>

Returns a reference to the value of the field with index index as a &dyn PartialReflect.

fn field_at_mut( &mut self, index: usize, ) -> Option<&mut (dyn PartialReflect + 'static)>

Returns a mutable reference to the value of the field with index index as a &mut dyn PartialReflect.

fn name_at(&self, index: usize) -> Option<&str>

Returns the name of the field with index index.

fn field_len(&self) -> usize

Returns the number of fields in the struct.

fn iter_fields(&self) -> FieldIter<'_>

Returns an iterator over the values of the reflectable fields for this struct.

fn to_dynamic_struct(&self) -> DynamicStruct

fn clone_dynamic(&self) -> DynamicStruct

👎Deprecated since 0.16.0: use to_dynamic_struct instead

Clones the struct into a DynamicStruct.

fn get_represented_struct_info(&self) -> Option<&'static StructInfo>

Will return None if TypeInfo is not available.

impl TypePath for TextLayout

where TextLayout: Any + Send + Sync,

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

fn type_ident() -> Option<&'static str>

Returns the name of the type, or None if it is anonymous.

fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or None if it is anonymous.

fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or None if it is anonymous.

impl Typed for TextLayout

where TextLayout: Any + Send + Sync, JustifyText: FromReflect + TypePath + MaybeTyped + RegisterForReflection, LineBreak: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl Copy for TextLayout