Exécution de l'écran

Fait partie de la section Object Oriented Programming du Journey Rust de Coddy. Leçon 53 sur 61.

Défi

Facile

Félicitations pour avoir atteint l'étape finale du projet Document System ! Vous avez construit toutes les pièces individuelles — le trait Draw, TextField, Button et Screen. Il est maintenant temps de donner à votre Screen la capacité de rendre tous ses composants à la fois avec un seul appel de méthode.

Vous allez terminer votre projet en ajoutant une méthode run à la structure Screen. Cette méthode itérera à travers tous les composants stockés dans l'écran et appellera draw() sur chacun d'eux, donnant ainsi vie à l'ensemble de votre système de documents.

Vos fichiers de projet :

draw.rs : Votre trait Draw avec la méthode draw.
text_field.rs : Votre composant TextField qui affiche Text: {content}.
button.rs : Votre composant Button qui affiche Button: {label} (width: {width}).
screen.rs : Votre structure Screen avec les méthodes new et add. Ajoutez une méthode run qui prend &self et appelle draw() sur chaque composant de la collection.
main.rs : Rassemblez tout — créez un Screen, ajoutez vos composants et appelez run() pour rendre l'écran entier d'un seul coup.

La méthode run encapsule la logique de rendu à l'intérieur de Screen, rendant votre fonction principale propre et simple. Au lieu d'itérer manuellement à travers les composants dans main, vous appelez simplement screen.run().

Les entrées suivantes seront fournies :

Première ligne : le contenu du champ de texte (text field)
Deuxième ligne : le libellé du bouton (button's label)
Troisième ligne : la largeur du bouton (sous forme de nombre)

Votre sortie doit afficher chaque composant sur sa propre ligne, dans l'ordre où ils ont été ajoutés :

Text: Dashboard
Button: Save (width: 120)

Essayez vous-même

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: Remplacer l'itération manuelle ci-dessous par un seul appel à screen.run()
    for component in &screen.components {
        component.draw();
    }
}