Uma Biblioteca GUI Simples

Vamos projetar uma biblioteca GUI clássica usando nosso novo conhecimento de traits e objetos de trait.

Teremos vários widgets em nossa biblioteca:

• Window: tem um título e contém outros widgets.
• Button: tem um rótulo e uma função de callback que é invocada quando o botão é pressionado.
• Label: tem um rótulo.

Os widgets irão implementar o trait Widget, veja abaixo.

Copie o código abaixo para https://play.rust-lang.org/, codifique os métodos draw_into para que você implemente o trait Widget:

// TODO: remove this when you're done with your implementation.
#![allow(unused_imports, unused_variables, dead_code)]

pub trait Widget {
    /// Natural width of `self`.
    fn width(&self) -> usize;

    /// Draw the widget into a buffer.
    fn draw_into(&self, buffer: &mut dyn std::fmt::Write);

    /// Draw the widget on standard output.
    fn draw(&self) {
        let mut buffer = String::new();
        self.draw_into(&mut buffer);
        println!("{buffer}");
    }
}

pub struct Label {
    label: String,
}

impl Label {
    fn new(label: &str) -> Label {
        Label {
            label: label.to_owned(),
        }
    }
}

pub struct Button {
    label: Label,
    callback: Box<dyn FnMut()>,
}

impl Button {
    fn new(label: &str, callback: Box<dyn FnMut()>) -> Button {
        Button {
            label: Label::new(label),
            callback,
        }
    }
}

pub struct Window {
    title: String,
    widgets: Vec<Box<dyn Widget>>,
}

impl Window {
    fn new(title: &str) -> Window {
        Window {
            title: title.to_owned(),
            widgets: Vec::new(),
        }
    }

    fn add_widget(&mut self, widget: Box<dyn Widget>) {
        self.widgets.push(widget);
    }

    fn inner_width(&self) -> usize {
        std::cmp::max(
            self.title.chars().count(),
            self.widgets.iter().map(|w| w.width()).max().unwrap_or(0),
        )
    }
}


impl Widget for Label {
    fn width(&self) -> usize {
        unimplemented!()
    }

    fn draw_into(&self, buffer: &mut dyn std::fmt::Write) {
        unimplemented!()
    }
}

impl Widget for Button {
    fn width(&self) -> usize {
        unimplemented!()
    }

    fn draw_into(&self, buffer: &mut dyn std::fmt::Write) {
        unimplemented!()
    }
}

impl Widget for Window {
    fn width(&self) -> usize {
        unimplemented!()
    }

    fn draw_into(&self, buffer: &mut dyn std::fmt::Write) {
        unimplemented!()
    }
}

fn main() {
    let mut window = Window::new("Rust GUI Demo 1.23");
    window.add_widget(Box::new(Label::new("This is a small text GUI demo.")));
    window.add_widget(Box::new(Button::new(
        "Click me!",
        Box::new(|| println!("You clicked the button!")),
    )));
    window.draw();
}

A saída do programa acima pode ser algo simples como:

========
Rust GUI Demo 1.23
========

This is a small text GUI demo.

| Click me! |

Se você quiser desenhar texto alinhado, você pode usar os operadores de formatação fill/alignment. Em particular, observe como você pode preencher com diferentes caracteres (aqui um '/') e como você pode controlar o alinhamento:

fn main() {
    let largura = 10;
    println!("alinhado à esquerda: |{:/<largura$}|", "foo");
    println!("centralizado: |{:/^largura$}|", "foo");
    println!("alinhado à direita: |{:/>largura$}|", "foo");
}

Usando esses truques de alinhamento, você pode, por exemplo, produzir uma saída como esta:

+--------------------------------+
|       Rust GUI Demo 1.23       |
+================================+
| This is a small text GUI demo. |
| +-----------+                  |
| | Click me! |                  |
| +-----------+                  |
+--------------------------------+