Struct Section

pub struct Section<'a, X = Extra> {
    pub screen_position: (f32, f32),
    pub bounds: (f32, f32),
    pub layout: Layout<BuiltInLineBreaker>,
    pub text: Vec<Text<'a, X>>,
}

An object that contains all the info to render a varied section of text. That is one including many parts with differing fonts/scales/colors bowing to a single layout.

Example

use glyph_brush::{HorizontalAlign, Layout, Section, Text};

let section = Section::default()
    .add_text(Text::new("The last word was ").with_color([0.0, 0.0, 0.0, 1.0]))
    .add_text(Text::new("RED").with_color([1.0, 0.0, 0.0, 1.0]))
    .with_layout(Layout::default().h_align(HorizontalAlign::Center));

Extra

Extra text section data is stored in a generic type, default Extra. To use custom extra data ensure your custom type implements Debug, Clone, PartialEq & Hash.

Fields

screen_position: (f32, f32)

Position on screen to render text, in pixels from top-left. Defaults to (0, 0).

bounds: (f32, f32)

Max (width, height) bounds, in pixels from top-left. Defaults to unbounded.

layout: Layout<BuiltInLineBreaker>

Built in layout, can be overridden with custom layout logic see queue_custom_layout

text: Vec<Text<'a, X>>

Text to render, rendered next to one another according the layout.

Implementations

impl<'a, X> Section<'a, X>

pub fn new() -> Self

impl Section<'_, ()>

pub fn builder() -> SectionBuilder

Return a SectionBuilder to fluently build up a Section.

impl<'a, X> Section<'a, X>

pub fn with_screen_position<P: Into<(f32, f32)>>(self, position: P) -> Self

pub fn with_bounds<P: Into<(f32, f32)>>(self, bounds: P) -> Self

pub fn with_layout<L: Into<Layout<BuiltInLineBreaker>>>(self, layout: L) -> Self

pub fn add_text<T: Into<Text<'a, X>>>(self, text: T) -> Self

pub fn with_text<X2>(self, text: Vec<Text<'_, X2>>) -> Section<'_, X2>

impl<'text, X: Clone> Section<'text, X>

pub fn to_owned(&self) -> OwnedSection<X>

Trait Implementations

impl<'a, X: Clone> Clone for Section<'a, X>

fn clone(&self) -> Section<'a, X>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, X: Debug> Debug for Section<'a, X>

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

Formats the value using the given formatter.

impl Default for Section<'static, Extra>

fn default() -> Self

Note this only works for X=Extra for more flexible use see Section::builder.

impl<'a, X: Clone> From<&'a OwnedSection<X>> for Section<'a, X>

fn from(owned: &'a OwnedSection<X>) -> Self

use glyph_brush::{OwnedSection, OwnedText, Section};

let section = OwnedSection::default().add_text(OwnedText::new("foo").with_extra(1usize));
let cow: Section<'_, usize> = (&section).into();

impl<'a> From<&'a OwnedVariedSection> for Section<'a>

fn from(owned: &'a OwnedVariedSection) -> Self

Converts to this type from the input type.

impl<X> From<&Section<'_, X>> for SectionGeometry

fn from(section: &Section<'_, X>) -> Self

Converts to this type from the input type.

impl<'a> From<&Section<'a>> for Section<'a>

fn from(s: &Section<'a>) -> Self

Converts to this type from the input type.

impl<'a> From<&Section<'a>> for VariedSection<'a>

fn from(s: &Section<'a>) -> Self

Converts to this type from the input type.

impl<'a, 'b, X: Clone> From<&'b Section<'a, X>> for Cow<'b, Section<'a, X>>

fn from(owned: &'b Section<'a, X>) -> Self

Converts to this type from the input type.

impl<'a> From<&VariedSection<'a>> for Section<'a>

fn from(s: &VariedSection<'a>) -> Self

Converts to this type from the input type.

impl<'a> From<Section<'a>> for Section<'a>

fn from(s: Section<'a>) -> Self

Converts to this type from the input type.

impl<'a, X: Clone> From<Section<'a, X>> for Cow<'a, Section<'a, X>>

fn from(owned: Section<'a, X>) -> Self

Converts to this type from the input type.

impl<'a, X> From<Text<'a, X>> for Section<'a, X>

fn from(text: Text<'a, X>) -> Self

Converts to this type from the input type.

impl<'a> From<VariedSection<'a>> for Section<'a>

fn from(s: VariedSection<'a>) -> Self

Converts to this type from the input type.

impl<'a, X> From<Vec<Text<'a, X>>> for Section<'a, X>

fn from(text: Vec<Text<'a, X>>) -> Self

Converts to this type from the input type.

impl<X: Hash> Hash for Section<'_, X>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a, X: PartialEq> PartialEq for Section<'a, X>

fn eq(&self, other: &Section<'a, X>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, X> StructuralPartialEq for Section<'a, X>