Ejecución de la pantalla

Parte de la sección Object Oriented Programming del Journey de Rust de Coddy. Lección 53 de 61.

Desafío

Fácil

¡Felicitaciones por llegar al paso final del proyecto del Sistema de Documentos! Has construido todas las piezas individuales: el trait Draw, TextField, Button y Screen. Ahora es el momento de darle a tu Screen la capacidad de renderizar todos sus componentes a la vez con una sola llamada a un método.

Completarás tu proyecto agregando un método run a la estructura Screen. Este método iterará a través de todos los componentes almacenados en la pantalla y llamará a draw() en cada uno, dando vida a todo tu sistema de documentos.

Tus archivos del proyecto:

draw.rs: Tu trait Draw con el método draw.
text_field.rs: Tu componente TextField que imprime "Text: {}".
button.rs: Tu componente Button que imprime "Button: {} (width: {})".
screen.rs: Tu estructura Screen con los métodos new y add. Agrega un método run que tome &self y llame a draw() en cada componente de la colección.
main.rs: Une todo: crea una Screen, agrega tus componentes y llama a run() para renderizar toda la pantalla de una sola vez.

El método run encapsula la lógica de renderizado dentro de Screen, haciendo que tu función principal sea limpia y sencilla. En lugar de iterar manualmente a través de los componentes en main, simplemente llamas a screen.run().

Se proporcionarán las siguientes entradas:

Primera línea: el contenido del campo de texto (text field)
Segunda línea: la etiqueta del botón (button's label)
Tercera línea: el ancho del botón (como un número)

Tu salida debe mostrar cada componente en su propia línea, en el orden en que fueron agregados:

Text: Dashboard
Button: Save (width: 120)

Pruébalo tú mismo

mod draw;
mod text_field;
mod button;
mod screen;

use draw::Draw;
use text_field::TextField;
use button::Button;
use screen::Screen;

pub struct Label {
    pub text: String,
}

impl Draw for Label {
    fn draw(&self) {
        println!("{}", self.text);
    }
}

fn main() {
    let mut input1 = String::new();
    std::io::stdin().read_line(&mut input1).expect("Failed to read line");
    let content = input1.trim().to_string();

    let mut input2 = String::new();
    std::io::stdin().read_line(&mut input2).expect("Failed to read line");
    let label = input2.trim().to_string();

    let mut input3 = String::new();
    std::io::stdin().read_line(&mut input3).expect("Failed to read line");
    let width: u32 = input3.trim().parse().expect("Failed to parse width");

    let mut screen = Screen::new();

    let text_field = TextField { content };
    screen.add(Box::new(text_field));

    let button = Button { label, width };
    screen.add(Box::new(button));

    // TODO: Reemplazar la iteración manual de abajo con una sola llamada a screen.run()
    for component in &screen.components {
        component.draw();
    }
}