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<X> Section<'_, X>

pub fn new() -> Section<'_, X>

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>(self, position: P) -> Section<'a, X>

where P: Into<(f32, f32)>,

pub fn with_bounds<P>(self, bounds: P) -> Section<'a, X>

where P: Into<(f32, f32)>,

pub fn with_layout<L>(self, layout: L) -> Section<'a, X>

where L: Into<Layout<BuiltInLineBreaker>>,

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

where T: Into<Text<'a, X>>,

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

impl<X> Section<'_, X>

where X: Clone,

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

Trait Implementations

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

where X: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

where X: Debug,

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

Formats the value using the given formatter.

impl Default for Section<'static>

fn default() -> Section<'static>

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

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

where X: Clone,

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

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) -> Section<'a>

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

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

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>) -> Section<'a, X>

Converts to this type from the input type.

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

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

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>>) -> Section<'a, X>

Converts to this type from the input type.

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

where X: Hash,

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

where H: Hasher,

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 for Section<'a, X>

where X: PartialEq,

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>