ch2: Implement rust version

Author: corona10

python/graphics.py

@@ -13,8 +13,12 @@ class Browser:
     def __init__(self):
         self.window = tkinter.Tk()
         self.scroll = 0
+        self.min_scroll = 0
+        self.max_scroll = 0
+        self.window.title('Browser-engineering')
         self.window.bind("<Up>", self.scrollup)
         self.window.bind("<Down>", self.scrolldown)
+        self.window.bind("<MouseWheel>", self.mousewheel)
         self.canvas = tkinter.Canvas(
             self.window,
             width=WIDTH,
@@ -32,6 +36,7 @@ def layout(self, text):
         display_list = []
         cursor_x, cursor_y = HSTEP, VSTEP
         for c in text:
+            self.max_scroll = max(self.max_scroll, cursor_y)
             display_list.append((cursor_x, cursor_y, c))
             cursor_x += HSTEP
             if cursor_x >= WIDTH - HSTEP or c == '\n':
@@ -50,13 +55,25 @@ def render(self):
 
     def scrolldown(self, e):
         self.scroll += SCROLL_STEP
+        self.scroll = min(self.max_scroll, self.scroll)
         self.render()
 
     def scrollup(self, e):
         self.scroll -= SCROLL_STEP
-        self.scroll = max(self.scroll, 0)
+        self.scroll = max(self.scroll, self.min_scroll)
         self.render()
 
+    def mousewheel(self, e):
+        if e.delta > 0:
+            self.scroll -= SCROLL_STEP
+            self.scroll = max(self.scroll, self.min_scroll)
+            self.render()
+        elif e.delta < 0:
+            self.scroll += SCROLL_STEP
+            self.scroll = min(self.max_scroll, self.scroll)
+            self.render()
+
+
 
 if __name__ == '__main__':
     import sys

rust/Cargo.toml

@@ -3,13 +3,20 @@ name = "browser-engineering"
 version = "0.1.0"
 edition = "2018"
 authors = [
-  "Seo Sanghyeon <sanxiyn@gmail.com>"
+  "Seo Sanghyeon <sanxiyn@gmail.com>",
+  "Dong-hee Na <donghee.na92@gmail.com",
 ]
 
-[[example]]
+[lib]
 name = "http"
+path = "src/http.rs"
+
+[[bin]]
+name = "browser"
+path = "src/main.rs"
 
 [dependencies]
+druid = "0.7.0"
 rustls = "0.19"
 webpki = "0.21"
 webpki-roots = "0.21"

rust/examples/http.rs renamed to rust/src/http.rs

@@ -55,13 +55,13 @@ fn split2<'a>(string: &'a str, delimiter: &str) -> Option<(&'a str, &'a str)> {
     Some((split.next()?, split.next()?))
 }
 
-fn request(url: &str) -> (HashMap<String, String>, Vec<u8>) {
+pub fn request(url: &str) -> (HashMap<String, String>, Vec<u8>) {
     // 1. Parse scheme
     let (scheme, url) = split2(url, "://").expect(MALFORMED_URL);
     let port = match scheme {
         "http" => 80,
         "https" => 443,
-        _ => panic!("Unknown scheme {}", scheme)
+        _ => panic!("Unknown scheme {}", scheme),
     };
 
     // 2. Parse host
@@ -110,7 +110,7 @@ fn request(url: &str) -> (HashMap<String, String>, Vec<u8>) {
     // 9. Check status
     match status {
         "200" => (),
-        _ => panic!("{}: {}", status, explanation)
+        _ => panic!("{}: {}", status, explanation),
     };
 
     // 10. Parse headers
@@ -134,30 +134,20 @@ fn request(url: &str) -> (HashMap<String, String>, Vec<u8>) {
     (headers, body)
 }
 
-fn show(body: &[u8]) {
+pub fn lex(body: &[u8]) -> String {
     // 13. Print content
     let mut in_angle = false;
+    let mut ret = String::new();
     for c in body {
         match *c {
             b'<' => in_angle = true,
             b'>' => in_angle = false,
             _ => {
                 if !in_angle {
-                    print!("{}", *c as char);
+                    ret.push(*c as char);
                 }
             }
         }
     }
-}
-
-fn load(url: &str) {
-    // 14. Wire up
-    let (_headers, body) = request(url);
-    show(&body);
-}
-
-fn main() {
-    // 15. Run from command line
-    let args: Vec<String> = std::env::args().collect();
-    load(&args[1]);
+    ret
 }

rust/src/main.rs

@@ -0,0 +1,132 @@
+use druid::piet::{FontFamily, Text, TextLayoutBuilder};
+use druid::widget::prelude::*;
+use druid::{AppLauncher, Color, LocalizedString, WindowDesc};
+use http::{lex, request};
+use std::cmp;
+
+static WIDTH: i32 = 800;
+static HEIGHT: i32 = 600;
+static HSTEP: i32 = 13;
+static VSTEP: i32 = 12;
+static SCROLL_STEP: i32 = 100;
+
+struct Character {
+    x: i32,
+    y: i32,
+    ch: char,
+}
+
+struct BrowserWidget {
+    display_list: Vec<Character>,
+    scroll: i32,
+    min_scroll: i32,
+    max_scroll: i32,
+}
+
+trait Browser {
+    fn load(&mut self, url: &str);
+}
+
+impl Browser for BrowserWidget {
+    fn load(&mut self, url: &str) {
+        let (_headers, body) = request(url);
+        let text = lex(&body);
+        let mut cursor_x = HSTEP;
+        let mut cursor_y = VSTEP;
+        for c in text.chars() {
+            self.max_scroll = cmp::max(self.max_scroll, cursor_y);
+            self.display_list.push(Character {
+                x: cursor_x,
+                y: cursor_y,
+                ch: c,
+            });
+            cursor_x += VSTEP;
+            if cursor_x >= WIDTH - HSTEP || c == '\n' {
+                cursor_y += VSTEP;
+                cursor_x = HSTEP;
+            }
+        }
+    }
+}
+
+impl Widget<i32> for BrowserWidget {
+    fn event(&mut self, ctx: &mut EventCtx, _event: &Event, _data: &mut i32, _env: &Env) {
+        match _event {
+            Event::Wheel(e) => {
+                if e.wheel_delta.y < 0.0 {
+                    self.scroll -= SCROLL_STEP;
+                    self.scroll = cmp::max(self.scroll, self.min_scroll);
+                } else if e.wheel_delta.y > 0.0 {
+                    self.scroll += SCROLL_STEP;
+                    self.scroll = cmp::min(self.scroll, self.max_scroll);
+                }
+                *_data = self.scroll;
+                ctx.request_update();
+            }
+            _ => {}
+        }
+    }
+
+    fn lifecycle(&mut self, _ctx: &mut LifeCycleCtx, _event: &LifeCycle, _data: &i32, _env: &Env) {}
+
+    fn update(&mut self, ctx: &mut UpdateCtx, old_data: &i32, data: &i32, _env: &Env) {
+        if old_data != data {
+            ctx.request_paint();
+        }
+    }
+
+    fn layout(
+        &mut self,
+        _layout_ctx: &mut LayoutCtx,
+        bc: &BoxConstraints,
+        _data: &i32,
+        _env: &Env,
+    ) -> Size {
+        bc.max()
+    }
+
+    fn paint(&mut self, ctx: &mut PaintCtx, _data: &i32, _env: &Env) {
+        let size = ctx.size();
+        let rect = size.to_rect();
+        ctx.fill(rect, &Color::WHITE);
+        for ch in &self.display_list {
+            if ch.y > self.scroll + HEIGHT {
+                continue;
+            }
+
+            if ch.y + VSTEP < self.scroll {
+                continue;
+            }
+
+            let text = ctx.text();
+            let layout = text
+                .new_text_layout(String::from(ch.ch))
+                .font(FontFamily::default(), 12.0)
+                .text_color(Color::BLACK)
+                .build()
+                .unwrap();
+            ctx.draw_text(&layout, (ch.x as f64, ch.y as f64 - self.scroll as f64));
+        }
+    }
+}
+
+pub fn main() {
+    let browser = || -> BrowserWidget {
+        let args: Vec<String> = std::env::args().collect();
+        let mut ret = BrowserWidget {
+            display_list: Vec::new(),
+            scroll: 0,
+            min_scroll: 0,
+            max_scroll: 0,
+        };
+        ret.load(&args[1]);
+        ret
+    };
+    let window = WindowDesc::new(browser)
+        .title(LocalizedString::new("Browser-engineering"))
+        .window_size((WIDTH as f64, HEIGHT as f64));
+    AppLauncher::with_window(window)
+        .use_simple_logger()
+        .launch(0)
+        .expect("launch failed");
+}