Day 3 Morning Exercise

A Simple GUI Library

(back to exercise)

  1. // Copyright 2022 Google LLC
  2. //
  3. // Licensed under the Apache License, Version 2.0 (the "License");
  4. // you may not use this file except in compliance with the License.
  5. // You may obtain a copy of the License at
  6. //
  7. //      http://www.apache.org/licenses/LICENSE-2.0
  8. //
  9. // Unless required by applicable law or agreed to in writing, software
  10. // distributed under the License is distributed on an "AS IS" BASIS,
  11. // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12. // See the License for the specific language governing permissions and
  13. // limitations under the License.
  15. // ANCHOR: setup
  16. pub trait Widget {
  17.     /// Natural width of `self`.
  18.     fn width(&self) -> usize;
  20.     /// Draw the widget into a buffer.
  21.     fn draw_into(&self, buffer: &mut dyn std::fmt::Write);
  23.     /// Draw the widget on standard output.
  24.     fn draw(&self) {
  25.         let mut buffer = String::new();
  26.         self.draw_into(&mut buffer);
  27.         println!("{buffer}");
  28.     }
  29. }
  31. pub struct Label {
  32.     label: String,
  33. }
  35. impl Label {
  36.     fn new(label: &str) -> Label {
  37.         Label {
  38.             label: label.to_owned(),
  39.         }
  40.     }
  41. }
  43. pub struct Button {
  44.     label: Label,
  45.     callback: Box<dyn FnMut()>,
  46. }
  48. impl Button {
  49.     fn new(label: &str, callback: Box<dyn FnMut()>) -> Button {
  50.         Button {
  51.             label: Label::new(label),
  52.             callback,
  53.         }
  54.     }
  55. }
  57. pub struct Window {
  58.     title: String,
  59.     widgets: Vec<Box<dyn Widget>>,
  60. }
  62. impl Window {
  63.     fn new(title: &str) -> Window {
  64.         Window {
  65.             title: title.to_owned(),
  66.             widgets: Vec::new(),
  67.         }
  68.     }
  70.     fn add_widget(&mut self, widget: Box<dyn Widget>) {
  71.         self.widgets.push(widget);
  72.     }
  73. }
  75. // ANCHOR_END: setup
  77. // ANCHOR: Window-width
  78. impl Widget for Window {
  79.     fn width(&self) -> usize {
  80.         // ANCHOR_END: Window-width
  81.         std::cmp::max(
  82.             self.title.chars().count(),
  83.             self.widgets.iter().map(|w| w.width()).max().unwrap_or(0),
  84.         )
  85.     }
  87.     // ANCHOR: Window-draw_into
  88.     fn draw_into(&self, buffer: &mut dyn std::fmt::Write) {
  89.         // ANCHOR_END: Window-draw_into
  90.         let mut inner = String::new();
  91.         for widget in &self.widgets {
  92.             widget.draw_into(&mut inner);
  93.         }
  95.         let window_width = self.width();
  97.         // TODO: after learning about error handling, you can change
  98.         // draw_into to return Result<(), std::fmt::Error>. Then use
  99.         // the ?-operator here instead of .unwrap().
  100.         writeln!(buffer, "+-{:-<window_width$}-+", "").unwrap();
  101.         writeln!(buffer, "| {:^window_width$} |", &self.title).unwrap();
  102.         writeln!(buffer, "+={:=<window_width$}=+", "").unwrap();
  103.         for line in inner.lines() {
  104.             writeln!(buffer, "| {:window_width$} |", line).unwrap();
  105.         }
  106.         writeln!(buffer, "+-{:-<window_width$}-+", "").unwrap();
  107.     }
  108. }
  110. // ANCHOR: Button-width
  111. impl Widget for Button {
  112.     fn width(&self) -> usize {
  113.         // ANCHOR_END: Button-width
  114.         self.label.width() + 8 // add a bit of padding
  115.     }
  117.     // ANCHOR: Button-draw_into
  118.     fn draw_into(&self, buffer: &mut dyn std::fmt::Write) {
  119.         // ANCHOR_END: Button-draw_into
  120.         let width = self.width();
  121.         let mut label = String::new();
  122.         self.label.draw_into(&mut label);
  124.         writeln!(buffer, "+{:-<width$}+", "").unwrap();
  125.         for line in label.lines() {
  126.             writeln!(buffer, "|{:^width$}|", &line).unwrap();
  127.         }
  128.         writeln!(buffer, "+{:-<width$}+", "").unwrap();
  129.     }
  130. }
  132. // ANCHOR: Label-width
  133. impl Widget for Label {
  134.     fn width(&self) -> usize {
  135.         // ANCHOR_END: Label-width
  136.         self.label
  137.             .lines()
  138.             .map(|line| line.chars().count())
  139.             .max()
  140.             .unwrap_or(0)
  141.     }
  143.     // ANCHOR: Label-draw_into
  144.     fn draw_into(&self, buffer: &mut dyn std::fmt::Write) {
  145.         // ANCHOR_END: Label-draw_into
  146.         writeln!(buffer, "{}", &self.label).unwrap();
  147.     }
  148. }
  150. // ANCHOR: main
  151. fn main() {
  152.     let mut window = Window::new("Rust GUI Demo 1.23");
  153.     window.add_widget(Box::new(Label::new("This is a small text GUI demo.")));
  154.     window.add_widget(Box::new(Button::new(
  155.         "Click me!",
  156.         Box::new(|| println!("You clicked the button!")),
  157.     )));
  158.     window.draw();
  159. }
  160. // ANCHOR_END: main