Struct Text 

pub struct Text { /* private fields */ }

Text struct

Text is a drawable entity that can be used to display text. The text need a MutResource because the text mut the internal texture of his font.

Implementations

impl Text

pub fn dump_texture(&mut self) -> Result<(), Box<dyn Error>>

Dump the font texture to a file

pub fn new(font: &Rc<RefCell<Font>>) -> Text

Create a new text from a font previously created

Examples found in repository

examples/font.rs (line 21)

fn main() {
    // Create drawer window
    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");

    // Create event handler
    let event_handler = EventHandler::new(&window);

    // Create font
    let font = Rc::new(RefCell::new(
        Font::from_path("examples/font/test.ttf").unwrap(),
    ));

    // Create text with font
    let mut text = Text::new(&font);
    text.set_content("Welcome to Gust you can write text and\na lot more !\t(Like tabs)");
    text.set_position(Vector::new(100.0, 100.0));

    // Create a 2nd text with font
    let mut text2 = Text::from_str(&font, "Salut !");
    text2.set_position(Vector::new(200.0, 200.0));
    text2.update();

    // Loop preparation
    window.set_clear_color(Color::new(0.0, 0.0, 0.0));
    window.enable_cursor();
    window.poll(None);
    while window.is_open() {
        // update text
        text.update();

        // Poll event
        window.poll_events();
        event_handler
            .fetch()
            .for_each(|event| handle(&event, &mut window, &mut text));

        // Draw process (Clear -> Draw -> Display)
        window.clear();
        window.draw(&text);
        window.draw(&text2);
        window.display();
    }
}

pub fn from_str(font: &Rc<RefCell<Font>>, content: &str) -> Text

Create a text from it’s content and a font

Examples found in repository

examples/multi_window.rs (line 49)

fn window2() -> Result<(), Box<Error>> {
    let mut window = Window::new(500, 500, "Hello2");
    let font = Rc::new(RefCell::new(
        Font::from_path("examples/font/terminus.ttf").unwrap(),
    ));
    let mut text = Text::from_str(&font, "I've been looking forward to this.");
    text.set_position(Vector::new(5.0, 40.0));
    let event_handler = EventHandler::new(&window);

    window.set_clear_color(Color::new(1.0, 0.0, 1.0));
    window.enable_cursor();
    window.poll(None);

    while window.is_open() {
        text.update();
        window.poll_events();

        for event in event_handler.fetch() {
            event_process(event, &mut window);
        }

        window.clear();
        window.draw(&mut text);
        window.display();
    }
    Ok(())
}

examples/font.rs (line 26)

fn main() {
    // Create drawer window
    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");

    // Create event handler
    let event_handler = EventHandler::new(&window);

    // Create font
    let font = Rc::new(RefCell::new(
        Font::from_path("examples/font/test.ttf").unwrap(),
    ));

    // Create text with font
    let mut text = Text::new(&font);
    text.set_content("Welcome to Gust you can write text and\na lot more !\t(Like tabs)");
    text.set_position(Vector::new(100.0, 100.0));

    // Create a 2nd text with font
    let mut text2 = Text::from_str(&font, "Salut !");
    text2.set_position(Vector::new(200.0, 200.0));
    text2.update();

    // Loop preparation
    window.set_clear_color(Color::new(0.0, 0.0, 0.0));
    window.enable_cursor();
    window.poll(None);
    while window.is_open() {
        // update text
        text.update();

        // Poll event
        window.poll_events();
        event_handler
            .fetch()
            .for_each(|event| handle(&event, &mut window, &mut text));

        // Draw process (Clear -> Draw -> Display)
        window.clear();
        window.draw(&text);
        window.draw(&text2);
        window.display();
    }
}

pub fn set_content(&mut self, content: &str)

Set the content of the text

Examples found in repository

examples/font.rs (line 22)

fn main() {
    // Create drawer window
    let mut window = Window::new(gust::WIDTH, gust::HEIGHT, "Hello");

    // Create event handler
    let event_handler = EventHandler::new(&window);

    // Create font
    let font = Rc::new(RefCell::new(
        Font::from_path("examples/font/test.ttf").unwrap(),
    ));

    // Create text with font
    let mut text = Text::new(&font);
    text.set_content("Welcome to Gust you can write text and\na lot more !\t(Like tabs)");
    text.set_position(Vector::new(100.0, 100.0));

    // Create a 2nd text with font
    let mut text2 = Text::from_str(&font, "Salut !");
    text2.set_position(Vector::new(200.0, 200.0));
    text2.update();

    // Loop preparation
    window.set_clear_color(Color::new(0.0, 0.0, 0.0));
    window.enable_cursor();
    window.poll(None);
    while window.is_open() {
        // update text
        text.update();

        // Poll event
        window.poll_events();
        event_handler
            .fetch()
            .for_each(|event| handle(&event, &mut window, &mut text));

        // Draw process (Clear -> Draw -> Display)
        window.clear();
        window.draw(&text);
        window.draw(&text2);
        window.display();
    }
}

pub fn content(&self) -> &String

Get the content of the text as &String

pub fn content_mut(&mut self) -> &mut String

Get the content of the text as &mut String

pub fn set_size(&mut self, size: u32)

Set the local font size

pub fn size(&self) -> u32

Get the local font size

Trait Implementations

impl Debug for Text

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

Formats the value using the given formatter.

impl Drawable for Text

fn update(&mut self)

Update the openGL state of the drawable entity Should be call often so be carefull when implementing.

fn draw<T: Drawer>(&self, target: &mut T)

Draw the drawable structure, you need a Drawer(Where the struct will be draw)

fn draw_with_context(&self, context: &mut Context<'_>)

Draw with a particular context

fn setup_draw(&self, context: &mut Context<'_>)

Setup the draw for the final system you don’t have to implement it in a normal drawable

impl DrawableMut for Text

fn draw_mut<T: Drawer>(&mut self, target: &mut T)

Mutable version of draw function.

fn draw_with_context_mut(&mut self, context: &mut Context<'_>)

Mutable draw context function.

impl Movable for Text

fn translate<T>(&mut self, offset: Vector<T>)

where T: Scalar + Into<f32>,

Move the sprite off the offset

fn set_position<T>(&mut self, pos: Vector<T>)

where T: Scalar + Into<f32>,

Set position of the sprite

fn get_position(&self) -> Vector<f32>

Get current position

impl Rotable for Text

fn rotate<T>(&mut self, _angle: T)

where T: Scalar + Into<f32>,

Rotate from the actual angle with the angle given in argument.

fn set_rotation<T>(&mut self, _angle: T)

where T: Scalar + Into<f32>,

Set the rotation of the Rotable struct.

fn get_rotation(&self) -> f32

Return the rotation of the struct.

impl Scalable for Text

fn scale<T>(&mut self, _factor: Vector<T>)

where T: Scalar + Into<f32>,

Scale the sprite from a factor

fn set_scale<T>(&mut self, _vec: Vector<T>)

where T: Scalar + Into<f32>,

Set the scale of the sprite

fn get_scale(&self) -> Vector<f32>

Get the current scale

impl Transformable for Text

fn contain<T>(&self, _point: Point<T>) -> bool

where T: Scalar + Into<f32>,

Move the sprite off the offset.

fn set_origin<T>(&mut self, _origin: Vector<T>)

where T: Scalar + Into<f32>,

Set the origin of the object.

fn get_origin(&self) -> Vector<f32>

Get the origin of the transformable.