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();
    }
}