.github/workflows/rust.yml

@@ -16,9 +16,7 @@ jobs:
 
     steps:
     - uses: actions/checkout@v4
-
-    - name: Install system dependencies
-      run: sudo apt-get install -y liblzma-dev libfontconfig1-dev
-
+    - name: Install liblzma-dev
+      run: sudo apt-get install -y liblzma-dev
     - name: Build
       run: cargo build --verbose

README.md

@@ -23,19 +23,7 @@ Without nix: check out this repository and use `cargo run --release`.
 
 ## Command line arguments
 
-```
-Usage: servicepoint-simulator [OPTIONS]
-
-Options:
-      --bind <BIND>  address and port to bind to [default: 0.0.0.0:2342]
-  -f, --font <FONT>  The name of the font family to use. This defaults to the system monospace font.
-  -s, --spacers      add spacers between tile rows to simulate gaps in real display
-  -r, --red          Use the red color channel
-  -g, --green        Use the green color channel
-  -b, --blue         Use the blue color channel
-  -v, --verbose      Set default log level lower. You can also change this via the RUST_LOG environment variable.
-  -h, --help         Print help
-```
+The application binds to `0.0.0.0:2342` by default (`./servicepoint-simulator --bind host:port` to change this).
 
 See [env_logger](https://docs.rs/env_logger/latest/env_logger/) to configure logging.
 

flake.nix

@@ -25,24 +25,97 @@
         "aarch64-darwin"
         "x86_64-darwin"
       ];
-      forAllSystems =
-        f:
-        lib.genAttrs supported-systems (
-          system:
-          f rec {
-            pkgs = nixpkgs.legacyPackages.${system};
-            inherit system;
-          }
-        );
+      forAllSystems = lib.genAttrs supported-systems;
+      make-rust-toolchain-core =
+        pkgs:
+        pkgs.symlinkJoin {
+          name = "rust-toolchain-core";
+          paths = with pkgs; [
+            rustc
+            cargo
+            rustPlatform.rustcSrc
+          ];
+        };
     in
     rec {
       packages = forAllSystems (
-        { pkgs, ... }:
-        rec {
-          servicepoint-simulator = import ./servicepoint-simulator.nix {
-            inherit nix-filter pkgs;
-            naersk' = pkgs.callPackage naersk { };
+        system:
+        let
+          pkgs = nixpkgs.legacyPackages."${system}";
+          rust-toolchain-core = make-rust-toolchain-core pkgs;
+          naersk' = pkgs.callPackage naersk {
+            cargo = rust-toolchain-core;
+            rustc = rust-toolchain-core;
           };
+        in
+        rec {
+          servicepoint-simulator = naersk'.buildPackage rec {
+            src = nix-filter.lib.filter {
+              root = ./.;
+              include = [
+                ./Cargo.toml
+                ./Cargo.lock
+                ./src
+                ./Web437_IBM_BIOS.woff
+                ./README.md
+                ./LICENSE
+              ];
+            };
+            nativeBuildInputs = with pkgs; [
+              pkg-config
+              makeWrapper
+            ];
+            strictDeps = true;
+            buildInputs =
+              with pkgs;
+              [
+                xe
+                xz
+              ]
+              ++ lib.optionals pkgs.stdenv.isLinux (
+                with pkgs;
+                [
+                  # gpu
+                  libGL
+                  vulkan-headers
+                  vulkan-loader
+                  vulkan-tools vulkan-tools-lunarg
+                  vulkan-extension-layer
+                  vulkan-validation-layers
+
+                  # keyboard
+                  libxkbcommon
+
+                   # font loading
+                  fontconfig
+                  freetype
+
+                  # WINIT_UNIX_BACKEND=wayland
+                  wayland
+
+                  # WINIT_UNIX_BACKEND=x11
+                  xorg.libXcursor
+                  xorg.libXrandr
+                  xorg.libXi
+                  xorg.libX11
+                  xorg.libX11.dev
+                ]
+              )
+              ++ lib.optionals pkgs.stdenv.isDarwin (
+                with pkgs.darwin.apple_sdk.frameworks;
+                [
+                  Carbon
+                  QuartzCore
+                  AppKit
+                ]
+              );
+
+            postInstall = ''
+              wrapProgram $out/bin/servicepoint-simulator \
+                --suffix LD_LIBRARY_PATH : ${lib.makeLibraryPath buildInputs}
+            '';
+          };
+
           default = servicepoint-simulator;
         }
       );
@@ -50,35 +123,29 @@
       legacyPackages = packages;
 
       devShells = forAllSystems (
-        {
-          pkgs,
-          system,
-        }:
+        system:
+        let
+          pkgs = nixpkgs.legacyPackages."${system}";
+          rust-toolchain = pkgs.symlinkJoin {
+            name = "rust-toolchain";
+            paths = with pkgs; [
+              (make-rust-toolchain-core pkgs)
+              rustfmt
+              clippy
+              cargo-expand
+            ];
+          };
+        in
         {
           default = pkgs.mkShell rec {
             inputsFrom = [ self.packages.${system}.default ];
-            packages = [
-              pkgs.gdb
-              (pkgs.symlinkJoin {
-                name = "rust-toolchain";
-                paths = with pkgs; [
-                  rustc
-                  cargo
-                  rustPlatform.rustcSrc
-                  rustfmt
-                  clippy
-                  cargo-expand
-                ];
-              })
-            ];
+            packages = [ rust-toolchain pkgs.gdb ];
             LD_LIBRARY_PATH = "${pkgs.lib.makeLibraryPath (builtins.concatMap (d: d.buildInputs) inputsFrom)}";
-            NIX_LD_LIBRARY_PATH = LD_LIBRARY_PATH;
-            NIX_LD = pkgs.stdenv.cc.bintools.dynamicLinker;
             RUST_SRC_PATH = "${pkgs.rust.packages.stable.rustPlatform.rustLibSrc}";
           };
         }
       );
 
-      formatter = forAllSystems ({ pkgs, ... }: pkgs.nixfmt-rfc-style);
+      formatter = forAllSystems (system: nixpkgs.legacyPackages."${system}".nixfmt-rfc-style);
     };
 }

servicepoint-simulator.nix

@@ -1,74 +0,0 @@
-{
-  naersk',
-  pkgs,
-  nix-filter,
-}:
-naersk'.buildPackage rec {
-  src = nix-filter.lib.filter {
-    root = ./.;
-    include = [
-      ./Cargo.toml
-      ./Cargo.lock
-      ./src
-      ./Web437_IBM_BIOS.woff
-      ./README.md
-      ./LICENSE
-    ];
-  };
-  nativeBuildInputs = with pkgs; [
-    pkg-config
-    makeWrapper
-  ];
-  strictDeps = true;
-  buildInputs =
-    with pkgs;
-    [
-      xe
-      xz
-
-      roboto
-    ]
-    ++ lib.optionals pkgs.stdenv.isLinux (
-      with pkgs;
-      [
-        # gpu
-        libGL
-        vulkan-headers
-        vulkan-loader
-        vulkan-tools
-        vulkan-tools-lunarg
-        vulkan-extension-layer
-        vulkan-validation-layers
-
-        # keyboard
-        libxkbcommon
-
-        # font loading
-        fontconfig
-        freetype
-
-        # WINIT_UNIX_BACKEND=wayland
-        wayland
-
-        # WINIT_UNIX_BACKEND=x11
-        xorg.libXcursor
-        xorg.libXrandr
-        xorg.libXi
-        xorg.libX11
-        xorg.libX11.dev
-      ]
-    )
-    ++ lib.optionals pkgs.stdenv.isDarwin (
-      with pkgs.darwin.apple_sdk.frameworks;
-      [
-        Carbon
-        QuartzCore
-        AppKit
-      ]
-    );
-
-  postInstall = ''
-    wrapProgram $out/bin/servicepoint-simulator \
-      --suffix LD_LIBRARY_PATH : ${pkgs.lib.makeLibraryPath buildInputs}
-  '';
-}

src/cli.rs

@@ -1,57 +0,0 @@
-use clap::Parser;
-
-#[derive(Parser, Debug)]
-pub struct Cli {
-    #[arg(
-        long,
-        default_value = "0.0.0.0:2342",
-        help = "address and port to bind to"
-    )]
-    pub bind: String,
-    #[arg(
-        short,
-        long,
-        help = "The name of the font family to use. This defaults to the system monospace font."
-    )]
-    pub font: Option<String>,
-    #[clap(flatten)]
-    pub gui: GuiOptions,
-    #[arg(
-        short,
-        long,
-        help = "Set default log level lower. You can also change this via the RUST_LOG environment variable."
-    )]
-    pub verbose: bool,
-}
-
-#[derive(Parser, Debug)]
-pub struct GuiOptions {
-    #[arg(
-        short,
-        long,
-        default_value_t = false,
-        help = "add spacers between tile rows to simulate gaps in real display"
-    )]
-    pub spacers: bool,
-    #[arg(
-        short,
-        long,
-        default_value_t = false,
-        help = "Use the red color channel"
-    )]
-    pub red: bool,
-    #[arg(
-        short,
-        long,
-        default_value_t = false,
-        help = "Use the green color channel"
-    )]
-    pub green: bool,
-    #[arg(
-        short,
-        long,
-        default_value_t = false,
-        help = "Use the blue color channel"
-    )]
-    pub blue: bool,
-}

src/execute_command.rs

@@ -1,246 +1,212 @@
-use crate::cp437_font::Cp437Font;
-use crate::execute_command::ExecutionResult::{Failure, Shutdown, Success};
-use crate::font_renderer::FontRenderer8x8;
 use log::{debug, error, info, trace, warn};
 use servicepoint::{
-    BitVec, Bitmap, BrightnessGrid, CharGrid, Command, Cp437Grid, Grid, Offset,
-    Origin, Tiles, PIXEL_COUNT, PIXEL_WIDTH, TILE_SIZE,
+    Bitmap, BrightnessGrid, CharGrid, Command, Cp437Grid, Grid, Origin, Tiles,
+    PIXEL_COUNT, PIXEL_WIDTH, TILE_SIZE,
 };
-use std::ops::{BitAnd, BitOr, BitXor};
-use std::sync::RwLock;
+use std::sync::{RwLock, RwLockWriteGuard};
 
-pub struct CommandExecutor<'t> {
-    display: &'t RwLock<Bitmap>,
-    luma: &'t RwLock<BrightnessGrid>,
-    cp437_font: Cp437Font,
-    font_renderer: FontRenderer8x8,
-}
+use crate::font::Cp437Font;
+use crate::font_renderer::FontRenderer8x8;
 
-#[must_use]
-pub enum ExecutionResult {
-    Success,
-    Failure,
-    Shutdown,
-}
-
-impl<'t> CommandExecutor<'t> {
-    pub fn new(
-        display: &'t RwLock<Bitmap>,
-        luma: &'t RwLock<BrightnessGrid>,
-        font_renderer: FontRenderer8x8,
-    ) -> Self {
-        CommandExecutor {
-            display,
-            luma,
-            font_renderer,
-            cp437_font: Cp437Font::default(),
+pub(crate) fn execute_command(
+    command: Command,
+    cp436_font: &Cp437Font,
+    utf8_font: &FontRenderer8x8,
+    display_ref: &RwLock<Bitmap>,
+    luma_ref: &RwLock<BrightnessGrid>,
+) -> bool {
+    debug!("received {command:?}");
+    match command {
+        Command::Clear => {
+            info!("clearing display");
+            display_ref.write().unwrap().fill(false);
         }
-    }
-
-    pub(crate) fn execute(&self, command: Command) -> ExecutionResult {
-        debug!("received {command:?}");
-        match command {
-            Command::Clear => {
-                info!("clearing display");
-                self.display.write().unwrap().fill(false);
-                Success
-            }
-            Command::HardReset => {
-                warn!("display shutting down");
-                Shutdown
-            }
-            Command::BitmapLinearWin(Origin { x, y, .. }, pixels, _) => {
-                self.print_pixel_grid(x, y, &pixels)
-            }
-            Command::Cp437Data(origin, grid) => {
-                self.print_cp437_data(origin, &grid)
-            }
-            #[allow(deprecated)]
-            Command::BitmapLegacy => {
-                warn!("ignoring deprecated command {:?}", command);
-                Failure
-            }
-            Command::BitmapLinearAnd(offset, vec, _) => {
-                self.execute_bitmap_linear(offset, vec, BitAnd::bitand)
-            }
-            Command::BitmapLinearOr(offset, vec, _) => {
-                self.execute_bitmap_linear(offset, vec, BitOr::bitor)
-            }
-            Command::BitmapLinearXor(offset, vec, _) => {
-                self.execute_bitmap_linear(offset, vec, BitXor::bitxor)
-            }
-            Command::BitmapLinear(offset, vec, _) => {
-                self.execute_bitmap_linear(offset, vec, move |_, new| new)
-            }
-            Command::CharBrightness(origin, grid) => {
-                self.execute_char_brightness(origin, grid)
-            }
-            Command::Brightness(brightness) => {
-                self.luma.write().unwrap().fill(brightness);
-                Success
-            }
-            Command::FadeOut => {
-                error!("command not implemented: {command:?}");
-                Success
-            }
-            Command::Utf8Data(origin, grid) => {
-                self.print_utf8_data(origin, &grid)
-            }
-        }
-    }
-
-    fn execute_char_brightness(
-        &self,
-        origin: Origin<Tiles>,
-        grid: BrightnessGrid,
-    ) -> ExecutionResult {
-        let mut luma = self.luma.write().unwrap();
-        for inner_y in 0..grid.height() {
-            for inner_x in 0..grid.width() {
-                let brightness = grid.get(inner_x, inner_y);
-                luma.set(origin.x + inner_x, origin.y + inner_y, brightness);
-            }
-        }
-        Success
-    }
-
-    fn execute_bitmap_linear<Op>(
-        &self,
-        offset: Offset,
-        vec: BitVec,
-        op: Op,
-    ) -> ExecutionResult
-    where
-        Op: Fn(bool, bool) -> bool,
-    {
-        if !Self::check_bitmap_valid(offset as u16, vec.len()) {
-            return Failure;
-        }
-        let mut display = self.display.write().unwrap();
-        for bitmap_index in 0..vec.len() {
-            let (x, y) = Self::get_coordinates_for_index(offset, bitmap_index);
-            let old_value = display.get(x, y);
-            display.set(x, y, op(old_value, vec[bitmap_index]));
-        }
-        Success
-    }
-
-    fn check_bitmap_valid(offset: u16, payload_len: usize) -> bool {
-        if offset as usize + payload_len > PIXEL_COUNT {
-            error!(
-                "bitmap with offset {offset} is too big ({payload_len} bytes)"
-            );
+        Command::HardReset => {
+            warn!("display shutting down");
             return false;
         }
+        Command::BitmapLinearWin(Origin { x, y, .. }, pixels, _) => {
+            let mut display = display_ref.write().unwrap();
+            print_pixel_grid(x, y, &pixels, &mut display);
+        }
+        Command::Cp437Data(origin, grid) => {
+            let mut display = display_ref.write().unwrap();
+            print_cp437_data(origin, &grid, cp436_font, &mut display);
+        }
+        #[allow(deprecated)]
+        Command::BitmapLegacy => {
+            warn!("ignoring deprecated command {:?}", command);
+        }
+        // TODO: how to deduplicate this code in a rusty way?
+        Command::BitmapLinear(offset, vec, _) => {
+            if !check_bitmap_valid(offset as u16, vec.len()) {
+                return true;
+            }
+            let mut display = display_ref.write().unwrap();
+            for bitmap_index in 0..vec.len() {
+                let (x, y) = get_coordinates_for_index(offset, bitmap_index);
+                display.set(x, y, vec[bitmap_index]);
+            }
+        }
+        Command::BitmapLinearAnd(offset, vec, _) => {
+            if !check_bitmap_valid(offset as u16, vec.len()) {
+                return true;
+            }
+            let mut display = display_ref.write().unwrap();
+            for bitmap_index in 0..vec.len() {
+                let (x, y) = get_coordinates_for_index(offset, bitmap_index);
+                let old_value = display.get(x, y);
+                display.set(x, y, old_value && vec[bitmap_index]);
+            }
+        }
+        Command::BitmapLinearOr(offset, vec, _) => {
+            if !check_bitmap_valid(offset as u16, vec.len()) {
+                return true;
+            }
+            let mut display = display_ref.write().unwrap();
+            for bitmap_index in 0..vec.len() {
+                let (x, y) = get_coordinates_for_index(offset, bitmap_index);
+                let old_value = display.get(x, y);
+                display.set(x, y, old_value || vec[bitmap_index]);
+            }
+        }
+        Command::BitmapLinearXor(offset, vec, _) => {
+            if !check_bitmap_valid(offset as u16, vec.len()) {
+                return true;
+            }
+            let mut display = display_ref.write().unwrap();
+            for bitmap_index in 0..vec.len() {
+                let (x, y) = get_coordinates_for_index(offset, bitmap_index);
+                let old_value = display.get(x, y);
+                display.set(x, y, old_value ^ vec[bitmap_index]);
+            }
+        }
+        Command::CharBrightness(origin, grid) => {
+            let mut luma = luma_ref.write().unwrap();
+            for inner_y in 0..grid.height() {
+                for inner_x in 0..grid.width() {
+                    let brightness = grid.get(inner_x, inner_y);
+                    luma.set(
+                        origin.x + inner_x,
+                        origin.y + inner_y,
+                        brightness,
+                    );
+                }
+            }
+        }
+        Command::Brightness(brightness) => {
+            luma_ref.write().unwrap().fill(brightness);
+        }
+        Command::FadeOut => {
+            error!("command not implemented: {command:?}")
+        }
+        Command::Utf8Data(origin, grid) => {
+            let mut display = display_ref.write().unwrap();
+            print_utf8_data(origin, &grid, utf8_font, &mut display);
+        }
+    };
 
-        true
+    true
+}
+
+fn check_bitmap_valid(offset: u16, payload_len: usize) -> bool {
+    if offset as usize + payload_len > PIXEL_COUNT {
+        error!("bitmap with offset {offset} is too big ({payload_len} bytes)");
+        return false;
     }
 
-    fn print_cp437_data(
-        &self,
-        origin: Origin<Tiles>,
-        grid: &Cp437Grid,
-    ) -> ExecutionResult {
-        let font = &self.cp437_font;
-        let Origin { x, y, .. } = origin;
-        for char_y in 0usize..grid.height() {
-            for char_x in 0usize..grid.width() {
-                let char_code = grid.get(char_x, char_y);
-                trace!(
+    true
+}
+
+fn print_cp437_data(
+    origin: Origin<Tiles>,
+    grid: &Cp437Grid,
+    font: &Cp437Font,
+    display: &mut RwLockWriteGuard<Bitmap>,
+) {
+    let Origin { x, y, .. } = origin;
+    for char_y in 0usize..grid.height() {
+        for char_x in 0usize..grid.width() {
+            let char_code = grid.get(char_x, char_y);
+            trace!(
                 "drawing char_code {char_code:#04x} (if this was UTF-8, it would be {})",
                 char::from(char_code)
             );
 
-                let tile_x = char_x + x;
-                let tile_y = char_y + y;
+            let tile_x = char_x + x;
+            let tile_y = char_y + y;
 
-                match self.print_pixel_grid(
-                    tile_x * TILE_SIZE,
-                    tile_y * TILE_SIZE,
-                    &font[char_code],
-                ) {
-                    Success => {}
-                    Failure => {
-                        error!(
-                            "stopping drawing text because char draw failed"
-                        );
-                        return Failure;
-                    }
-                    Shutdown => return Shutdown,
-                }
+            let bitmap = font.get_bitmap(char_code);
+            if !print_pixel_grid(
+                tile_x * TILE_SIZE,
+                tile_y * TILE_SIZE,
+                bitmap,
+                display,
+            ) {
+                error!("stopping drawing text because char draw failed");
+                return;
             }
         }
-
-        Success
-    }
-
-    fn print_utf8_data(
-        &self,
-        origin: Origin<Tiles>,
-        grid: &CharGrid,
-    ) -> ExecutionResult {
-        let mut display = self.display.write().unwrap();
-
-        let Origin { x, y, .. } = origin;
-        for char_y in 0usize..grid.height() {
-            for char_x in 0usize..grid.width() {
-                let char = grid.get(char_x, char_y);
-                trace!("drawing {char}");
-
-                let tile_x = char_x + x;
-                let tile_y = char_y + y;
-
-                if let Err(e) = self.font_renderer.render(
-                    char,
-                    &mut display,
-                    Origin::new(tile_x * TILE_SIZE, tile_y * TILE_SIZE),
-                ) {
-                    error!(
-                        "stopping drawing text because char draw failed: {e}"
-                    );
-                    return Failure;
-                }
-            }
-        }
-
-        Success
-    }
-
-    fn print_pixel_grid(
-        &self,
-        offset_x: usize,
-        offset_y: usize,
-        pixels: &Bitmap,
-    ) -> ExecutionResult {
-        debug!(
-            "printing {}x{} grid at {offset_x} {offset_y}",
-            pixels.width(),
-            pixels.height()
-        );
-        let mut display = self.display.write().unwrap();
-        for inner_y in 0..pixels.height() {
-            for inner_x in 0..pixels.width() {
-                let is_set = pixels.get(inner_x, inner_y);
-                let x = offset_x + inner_x;
-                let y = offset_y + inner_y;
-
-                if x >= display.width() || y >= display.height() {
-                    error!("stopping pixel grid draw because coordinate {x} {y} is out of bounds");
-                    return Failure;
-                }
-
-                display.set(x, y, is_set);
-            }
-        }
-
-        Success
-    }
-
-    fn get_coordinates_for_index(
-        offset: usize,
-        index: usize,
-    ) -> (usize, usize) {
-        let pixel_index = offset + index;
-        (pixel_index % PIXEL_WIDTH, pixel_index / PIXEL_WIDTH)
     }
 }
+
+fn print_utf8_data(
+    origin: Origin<Tiles>,
+    grid: &CharGrid,
+    font: &FontRenderer8x8,
+    display: &mut RwLockWriteGuard<Bitmap>,
+) {
+    let Origin { x, y, .. } = origin;
+    for char_y in 0usize..grid.height() {
+        for char_x in 0usize..grid.width() {
+            let char = grid.get(char_x, char_y);
+            trace!("drawing {char}");
+
+            let tile_x = char_x + x;
+            let tile_y = char_y + y;
+
+            if let Err(e) = font.render(
+                char,
+                display,
+                Origin::new(tile_x * TILE_SIZE, tile_y * TILE_SIZE),
+            ) {
+                error!("stopping drawing text because char draw failed: {e}");
+                return;
+            }
+        }
+    }
+}
+
+fn print_pixel_grid(
+    offset_x: usize,
+    offset_y: usize,
+    pixels: &Bitmap,
+    display: &mut RwLockWriteGuard<Bitmap>,
+) -> bool {
+    debug!(
+        "printing {}x{} grid at {offset_x} {offset_y}",
+        pixels.width(),
+        pixels.height()
+    );
+    for inner_y in 0..pixels.height() {
+        for inner_x in 0..pixels.width() {
+            let is_set = pixels.get(inner_x, inner_y);
+            let x = offset_x + inner_x;
+            let y = offset_y + inner_y;
+
+            if x >= display.width() || y >= display.height() {
+                error!("stopping pixel grid draw because coordinate {x} {y} is out of bounds");
+                return false;
+            }
+
+            display.set(x, y, is_set);
+        }
+    }
+
+    true
+}
+
+fn get_coordinates_for_index(offset: usize, index: usize) -> (usize, usize) {
+    let pixel_index = offset + index;
+    (pixel_index % PIXEL_WIDTH, pixel_index / PIXEL_WIDTH)
+}

src/font.rs

@@ -0,0 +1,297 @@
+use servicepoint::{Bitmap, DataRef, TILE_SIZE};
+
+const CHAR_COUNT: usize = u8::MAX as usize + 1;
+
+pub struct Cp437Font {
+    bitmaps: [Bitmap; CHAR_COUNT],
+}
+
+impl Cp437Font {
+    pub fn new(bitmaps: [Bitmap; CHAR_COUNT]) -> Self {
+        Self { bitmaps }
+    }
+
+    pub fn get_bitmap(&self, char_code: u8) -> &Bitmap {
+        &self.bitmaps[char_code as usize]
+    }
+}
+
+impl Default for Cp437Font {
+    fn default() -> Self {
+        load_static()
+    }
+}
+
+/// Font from the display firmware `cape-cccb-apd/cp437font_linear.h`
+pub(crate) const CP437_FONT_LINEAR: [u64; 256] = [
+    0x0000000000000000, // 0x00
+    0x003854ba82aa4438, // 0x01
+    0x003844bafed67c38, // 0x02
+    0x0010387cfeee4400, // 0x03
+    0x0010387cfe7c3810, // 0x04
+    0x003810d6fefe3838, // 0x05
+    0x003810d6fe7c3810, // 0x06
+    0x0000387c7c7c3800, // 0x07
+    0x00fec6828282c6fe, // 0x08
+    0x0000384444443800, // 0x09
+    0x00fec6bababac6fe, // 0x0a
+    0x007088888a7a061e, // 0x0b
+    0x1038103844444438, // 0x0c
+    0x0030301010141418, // 0x0d
+    0xc0c64642724e720e, // 0x0e
+    0x00927c44c6447c92, // 0x0f
+    0x00c0f0fcfefcf0c0, // 0x10
+    0x00061e7efe7e1e06, // 0x11
+    0x1038541010543810, // 0x12
+    0x2800282828282828, // 0x13
+    0x000e0a0a7a8a8a7e, // 0x14
+    0x0038441c28704438, // 0x15
+    0x000000ffff000000, // 0x16
+    0xfe10385410543810, // 0x17
+    0x1010101010543810, // 0x18
+    0x1038541010101010, // 0x19
+    0x00000804fe040800, // 0x1a
+    0x00002040fe402000, // 0x1b
+    0xffffc0c0c0c0c0c0, // 0x1c
+    0x00002844fe442800, // 0x1d
+    0x00fefe7c7c383810, // 0x1e
+    0x001038387c7cfefe, // 0x1f
+    0x0000000000000000, // 0x20
+    0x1000101010101010, // 0x21
+    0x0000000000505028, // 0x22
+    0x00247e24247e2400, // 0x23
+    0x1038541830543810, // 0x24
+    0x00844a2a54a8a442, // 0x25
+    0x003a444a32484830, // 0x26
+    0x0000000000201010, // 0x27
+    0x0810202020201008, // 0x28
+    0x2010080808081020, // 0x29
+    0x0010543854100000, // 0x2a
+    0x0010107c10100000, // 0x2b
+    0x2010100000000000, // 0x2c
+    0x0000007c00000000, // 0x2d
+    0x0010000000000000, // 0x2e
+    0x4020201010080804, // 0x2f
+    0x0038444454444438, // 0x30
+    0x007c101010503010, // 0x31
+    0x007c201008044438, // 0x32
+    0x003844043810087c, // 0x33
+    0x0004047e24140c04, // 0x34
+    0x003844047840407c, // 0x35
+    0x003844447840201c, // 0x36
+    0x004020100804047c, // 0x37
+    0x0038444438444438, // 0x38
+    0x007008043c444438, // 0x39
+    0x0000100000100000, // 0x3a
+    0x2010100000100000, // 0x3b
+    0x0006186018060000, // 0x3c
+    0x00007c007c000000, // 0x3d
+    0x00c0300c30c00000, // 0x3e
+    0x1000384038044438, // 0x3f
+    0x001c2248564a221c, // 0x40
+    0x0042427e24241818, // 0x41
+    0x007c42427c444478, // 0x42
+    0x001c22404040221c, // 0x43
+    0x0078444242424478, // 0x44
+    0x007e40407e40407e, // 0x45
+    0x004040407e40407e, // 0x46
+    0x001c22424e40221c, // 0x47
+    0x004242427e424242, // 0x48
+    0x007c10101010107c, // 0x49
+    0x003844040404047c, // 0x4a
+    0x0042444870484442, // 0x4b
+    0x007e404040404040, // 0x4c
+    0x0082828292aac682, // 0x4d
+    0x004242464a526242, // 0x4e
+    0x0018244242422418, // 0x4f
+    0x004040407c42427c, // 0x50
+    0x001a244a42422418, // 0x51
+    0x004244487c42427c, // 0x52
+    0x003c42023c40423c, // 0x53
+    0x00101010101010fe, // 0x54
+    0x003c424242424242, // 0x55
+    0x0010282844448282, // 0x56
+    0x0044446caa929282, // 0x57
+    0x0082442810284482, // 0x58
+    0x0010101010284482, // 0x59
+    0x007e20100804027e, // 0x5a
+    0x3820202020202038, // 0x5b
+    0x0408081010202040, // 0x5c
+    0x3808080808080838, // 0x5d
+    0x0000000000442810, // 0x5e
+    0x007e000000000000, // 0x5f
+    0x0000000000080810, // 0x60
+    0x003c443c04380000, // 0x61
+    0x0038444444784040, // 0x62
+    0x0038444044380000, // 0x63
+    0x003c4444443c0404, // 0x64
+    0x003c407844380000, // 0x65
+    0x2020202078202418, // 0x66
+    0x78043c44443e0000, // 0x67
+    0x0044444464584040, // 0x68
+    0x001c101010700010, // 0x69
+    0x38440404047c0010, // 0x6a
+    0x0022243828242020, // 0x6b
+    0x0018242020202020, // 0x6c
+    0x0054545454780000, // 0x6d
+    0x0044444464580000, // 0x6e
+    0x0038444444380000, // 0x6f
+    0x4040784444780000, // 0x70
+    0x04043c44443c0000, // 0x71
+    0x0040404064580000, // 0x72
+    0x00384418201c0000, // 0x73
+    0x0018242020782020, // 0x74
+    0x0038444444440000, // 0x75
+    0x0010282844440000, // 0x76
+    0x0028285454440000, // 0x77
+    0x0044281028440000, // 0x78
+    0x38043c4444440000, // 0x79
+    0x007c2010087c0000, // 0x7a
+    0x0c0808083008080c, // 0x7b
+    0x1010101010101010, // 0x7c
+    0x301010100c101030, // 0x7d
+    0x0000004c32000000, // 0x7e
+    0xfe82828282442810, // 0x7f
+    0x18083c428080423c, // 0x80
+    0x0038444444440028, // 0x81
+    0x003c407844381008, // 0x82
+    0x003c443c04382810, // 0x83
+    0x003c443c04380044, // 0x84
+    0x003c443c04381020, // 0x85
+    0x003c443c04382838, // 0x86
+    0x1038444044380000, // 0x87
+    0x003c407844382810, // 0x88
+    0x003c407844380044, // 0x89
+    0x003c407844381020, // 0x8a
+    0x001c101010700028, // 0x8b
+    0x001c101010702810, // 0x8c
+    0x001c101010701020, // 0x8d
+    0x0082827c44282892, // 0x8e
+    0x0082827c44281038, // 0x8f
+    0x00fe80fe80fe1008, // 0x90
+    0x007e907c126c0000, // 0x91
+    0x008e88784e28281e, // 0x92
+    0x0038444438002810, // 0x93
+    0x0038444444380028, // 0x94
+    0x0038444438001020, // 0x95
+    0x0038444444002810, // 0x96
+    0x0038444444001020, // 0x97
+    0x38043c4444440028, // 0x98
+    0x0038448282443882, // 0x99
+    0x0038448282820082, // 0x9a
+    0x1038444044381010, // 0x9b
+    0x00fc4240f0404438, // 0x9c
+    0x107c107c10284482, // 0x9d
+    0x001c22f840f8221c, // 0x9e
+    0x205010103810120c, // 0x9f
+    0x003c443c04381008, // 0xa0
+    0x001c101010701008, // 0xa1
+    0x0038444438001008, // 0xa2
+    0x0038444444001008, // 0xa3
+    0x0044446458004834, // 0xa4
+    0x00464a5262424834, // 0xa5
+    0x0000007090701060, // 0xa6
+    0x0000007088888870, // 0xa7
+    0x3844403804380010, // 0xa8
+    0x0040407c00000000, // 0xa9
+    0x0004047c00000000, // 0xaa
+    0x0e84422c5048c442, // 0xab
+    0x049e542c5448c442, // 0xac
+    0x1010101010100010, // 0xad
+    0x0024489048240000, // 0xae
+    0x0048241224480000, // 0xaf
+    0x1122448811224488, // 0xb0
+    0x55aa55aa55aa55aa, // 0xb1
+    0xddbb77eeddbb77ee, // 0xb2
+    0x1010101010101010, // 0xb3
+    0x101020c020101010, // 0xb4
+    0x1020c000c0201010, // 0xb5
+    0x2828488848282828, // 0xb6
+    0x282850e000000000, // 0xb7
+    0x1030d020c0000000, // 0xb8
+    0x2848880888482828, // 0xb9
+    0x2828282828282828, // 0xba
+    0x2828c810e0000000, // 0xbb
+    0x000000e010c82828, // 0xbc
+    0x000000e050282828, // 0xbd
+    0x0000c020d0301010, // 0xbe
+    0x101020c000000000, // 0xbf
+    0x0000000708101010, // 0xc0
+    0x000000c728101010, // 0xc1
+    0x101028c700000000, // 0xc2
+    0x1010080708101010, // 0xc3
+    0x000000ff00000000, // 0xc4
+    0x101028c728101010, // 0xc5
+    0x1008070007081010, // 0xc6
+    0x2828242324282828, // 0xc7
+    0x00000f1027282828, // 0xc8
+    0x282827100f000000, // 0xc9
+    0x0000ff0083442828, // 0xca
+    0x28448300ff000000, // 0xcb
+    0x2824232023242828, // 0xcc
+    0x0000ff00ff000000, // 0xcd
+    0x2844932893442828, // 0xce
+    0x0000ff00c7281010, // 0xcf
+    0x0000008344282828, // 0xd0
+    0x1028c700ff000000, // 0xd1
+    0x2828448300000000, // 0xd2
+    0x0000000f14282828, // 0xd3
+    0x0000070817181010, // 0xd4
+    0x1018170807000000, // 0xd5
+    0x2828140f00000000, // 0xd6
+    0x2828448344282828, // 0xd7
+    0x1028c700c7281010, // 0xd8
+    0x000000c020101010, // 0xd9
+    0x1010080700000000, // 0xda
+    0xffffffffffffffff, // 0xdb
+    0xffffffff00000000, // 0xdc
+    0xf0f0f0f0f0f0f0f0, // 0xdd
+    0x0f0f0f0f0f0f0f0f, // 0xde
+    0x00000000ffffffff, // 0xdf
+    0x0076888888740200, // 0xe0
+    0x5844444458484830, // 0xe1
+    0x00e04040404242fe, // 0xe2
+    0x00242828a87c0000, // 0xe3
+    0x00fe8240204082fe, // 0xe4
+    0x00384444443e0000, // 0xe5
+    0x405a644444440000, // 0xe6
+    0x0010282020fc0000, // 0xe7
+    0xfe103854543810fe, // 0xe8
+    0x003844aabaaa4438, // 0xe9
+    0x00ee448282824438, // 0xea
+    0x007088887012221c, // 0xeb
+    0x00006c92926c0000, // 0xec
+    0x10107c92924c0000, // 0xed
+    0x0038403040380000, // 0xee
+    0x0082828282824438, // 0xef
+    0x00fe00fe00fe0000, // 0xf0
+    0x007c10107c101000, // 0xf1
+    0x007e006018061860, // 0xf2
+    0x007e000618601806, // 0xf3
+    0x101010101010120c, // 0xf4
+    0x6090101010101010, // 0xf5
+    0x0010007c00100000, // 0xf6
+    0x000c926c92600000, // 0xf7
+    0x0000000030484830, // 0xf8
+    0x0000103810000000, // 0xf9
+    0x0000001000000000, // 0xfa
+    0x10102828a4440202, // 0xfb
+    0x00000000484848b0, // 0xfc
+    0x0000000070201060, // 0xfd
+    0x00007c7c7c7c7c00, // 0xfe
+    0x0000000000000000, // 0xff
+];
+
+fn load_static() -> Cp437Font {
+    let mut bitmaps =
+        core::array::from_fn(|_| Bitmap::new(TILE_SIZE, TILE_SIZE));
+
+    for (char_code, bitmap) in bitmaps.iter_mut().enumerate() {
+        let bits = CP437_FONT_LINEAR[char_code];
+        let mut bytes = bits.to_be_bytes();
+        bytes.reverse();
+        bitmap.data_ref_mut().copy_from_slice(bytes.as_slice());
+    }
+
+    Cp437Font::new(bitmaps)
+}

src/font_renderer.rs

@@ -1,33 +1,18 @@
 use crate::font_renderer::RenderError::{GlyphNotFound, OutOfBounds};
-use font_kit::{
-    canvas::{Canvas, Format, RasterizationOptions},
-    error::GlyphLoadingError,
-    family_name::FamilyName,
-    font::Font,
-    hinting::HintingOptions,
-    properties::Properties,
-    source::SystemSource,
-};
-use pathfinder_geometry::{
-    transform2d::Transform2F,
-    vector::{vec2f, vec2i},
-};
+use font_kit::canvas::{Canvas, Format, RasterizationOptions};
+use font_kit::error::GlyphLoadingError;
+use font_kit::family_name::FamilyName;
+use font_kit::font::Font;
+use font_kit::hinting::HintingOptions;
+use font_kit::properties::Properties;
+use font_kit::source::SystemSource;
+use pathfinder_geometry::transform2d::Transform2F;
+use pathfinder_geometry::vector::{vec2f, vec2i};
 use servicepoint::{Bitmap, Grid, Origin, Pixels, TILE_SIZE};
-use std::sync::{Mutex, MutexGuard};
-
-struct SendFont(Font);
-
-// struct is only using primitives and pointers - lets try if it is only missing the declaration
-unsafe impl Send for SendFont {}
-
-impl AsRef<Font> for SendFont {
-    fn as_ref(&self) -> &Font {
-        &self.0
-    }
-}
+use std::sync::Mutex;
 
 pub struct FontRenderer8x8 {
-    font: SendFont,
+    font: Font,
     canvas: Mutex<Canvas>,
     fallback_char: Option<u32>,
 }
@@ -43,44 +28,35 @@ pub enum RenderError {
 }
 
 impl FontRenderer8x8 {
-    const FALLBACK_CHAR: char = '?';
-    pub fn new(font: Font) -> Self {
+    pub fn new(font: Font, fallback_char: Option<char>) -> Self {
         let canvas =
             Canvas::new(vec2i(TILE_SIZE as i32, TILE_SIZE as i32), Format::A8);
         assert_eq!(canvas.pixels.len(), TILE_SIZE * TILE_SIZE);
         assert_eq!(canvas.stride, TILE_SIZE);
-        let fallback_char = font.glyph_for_char(Self::FALLBACK_CHAR);
+        let fallback_char = fallback_char.and_then(|c| font.glyph_for_char(c));
         let result = Self {
-            font: SendFont(font),
+            font,
             fallback_char,
             canvas: Mutex::new(canvas),
         };
         result
     }
 
-    pub fn from_name(family_name: String) -> Self {
-        let font = SystemSource::new()
-            .select_best_match(
-                &[FamilyName::Title(family_name)],
-                &Properties::new(),
-            )
-            .unwrap()
-            .load()
-            .unwrap();
-        Self::new(font)
-    }
-
     pub fn render(
         &self,
         char: char,
         bitmap: &mut Bitmap,
         offset: Origin<Pixels>,
     ) -> Result<(), RenderError> {
-        let glyph_id = self.get_glyph(char)?;
-
         let mut canvas = self.canvas.lock().unwrap();
+        let glyph_id = self.font.glyph_for_char(char).or(self.fallback_char);
+        let glyph_id = match glyph_id {
+            None => return Err(GlyphNotFound(char)),
+            Some(val) => val,
+        };
+
         canvas.pixels.fill(0);
-        self.font.as_ref().rasterize_glyph(
+        self.font.rasterize_glyph(
             &mut canvas,
             glyph_id,
             TILE_SIZE as f32,
@@ -90,17 +66,10 @@ impl FontRenderer8x8 {
             RasterizationOptions::Bilevel,
         )?;
 
-        Self::copy_to_bitmap(canvas, bitmap, offset)
-    }
-
-    fn copy_to_bitmap(
-        canvas: MutexGuard<Canvas>,
-        bitmap: &mut Bitmap,
-        offset: Origin<Pixels>,
-    ) -> Result<(), RenderError> {
         for y in 0..TILE_SIZE {
             for x in 0..TILE_SIZE {
-                let canvas_val = canvas.pixels[x + y * TILE_SIZE] != 0;
+                let index = x + y * TILE_SIZE;
+                let canvas_val = canvas.pixels[index] != 0;
                 let bitmap_x = (offset.x + x) as isize;
                 let bitmap_y = (offset.y + y) as isize;
                 if !bitmap.set_optional(bitmap_x, bitmap_y, canvas_val) {
@@ -108,15 +77,8 @@ impl FontRenderer8x8 {
                 }
             }
         }
-        Ok(())
-    }
 
-    fn get_glyph(&self, char: char) -> Result<u32, RenderError> {
-        self.font
-            .as_ref()
-            .glyph_for_char(char)
-            .or(self.fallback_char)
-            .ok_or_else(|| GlyphNotFound(char))
+        Ok(())
     }
 }
 
@@ -127,6 +89,6 @@ impl Default for FontRenderer8x8 {
             .unwrap()
             .load()
             .unwrap();
-        FontRenderer8x8::new(utf8_font)
+        FontRenderer8x8::new(utf8_font, Some('?'))
     }
 }

src/gui.rs

@@ -1,10 +1,12 @@
-use std::slice::ChunksExactMut;
 use std::sync::mpsc::Sender;
 use std::sync::RwLock;
 
 use log::{info, warn};
 use pixels::{Pixels, SurfaceTexture};
-use servicepoint::*;
+use servicepoint::{
+    Bitmap, Brightness, BrightnessGrid, Grid, PIXEL_HEIGHT, PIXEL_WIDTH,
+    TILE_SIZE,
+};
 use winit::application::ApplicationHandler;
 use winit::dpi::LogicalSize;
 use winit::event::WindowEvent;
@@ -12,23 +14,18 @@ use winit::event_loop::ActiveEventLoop;
 use winit::keyboard::KeyCode::KeyC;
 use winit::window::{Window, WindowId};
 
-use crate::cli::GuiOptions;
+use crate::Cli;
 
-pub struct Gui<'t> {
+pub struct App<'t> {
     display: &'t RwLock<Bitmap>,
     luma: &'t RwLock<BrightnessGrid>,
     window: Option<Window>,
     stop_udp_tx: Sender<()>,
-    options: GuiOptions,
+    cli: &'t Cli,
     logical_size: LogicalSize<u16>,
 }
 
 const SPACER_HEIGHT: usize = 4;
-const NUM_SPACERS: usize = (PIXEL_HEIGHT / TILE_SIZE) - 1;
-const PIXEL_HEIGHT_WITH_SPACERS: usize =
-    PIXEL_HEIGHT + NUM_SPACERS * SPACER_HEIGHT;
-
-const OFF_COLOR: [u8; 4] = [0u8, 0, 0, 255];
 
 #[derive(Debug)]
 pub enum AppEvents {
@@ -36,99 +33,91 @@ pub enum AppEvents {
     UdpThreadClosed,
 }
 
-impl<'t> Gui<'t> {
+impl<'t> App<'t> {
     pub fn new(
         display: &'t RwLock<Bitmap>,
         luma: &'t RwLock<BrightnessGrid>,
         stop_udp_tx: Sender<()>,
-        options: GuiOptions,
+        cli: &'t Cli,
     ) -> Self {
-        Gui {
-            window: None,
-            logical_size: Self::get_logical_size(options.spacers),
+        let logical_size = {
+            let height = if cli.spacers {
+                let num_spacers = (PIXEL_HEIGHT / TILE_SIZE) - 1;
+                PIXEL_HEIGHT + num_spacers * SPACER_HEIGHT
+            } else {
+                PIXEL_HEIGHT
+            };
+            LogicalSize::new(PIXEL_WIDTH as u16, height as u16)
+        };
+
+        App {
             display,
             luma,
             stop_udp_tx,
-            options,
+            window: None,
+            cli,
+            logical_size,
         }
     }
 
     fn draw(&mut self) {
         let window = self.window.as_ref().unwrap();
-        let window_size = window.inner_size();
-        let surface_texture =
-            SurfaceTexture::new(window_size.width, window_size.height, &window);
-
-        // TODO: fix pixels: creating a new instance per draw crashes after some time on macOS,
-        // but keeping one instance for the lifetime of the Gui SIGSEGVs on Wayland when entering a background state.
-        let mut pixels = Pixels::new(
-            self.logical_size.width as u32,
-            self.logical_size.height as u32,
-            surface_texture,
-        )
-        .unwrap();
+        let mut pixels = {
+            let window_size = window.inner_size();
+            let surface_texture = SurfaceTexture::new(
+                window_size.width,
+                window_size.height,
+                &window,
+            );
+            Pixels::new(
+                self.logical_size.width as u32,
+                self.logical_size.height as u32,
+                surface_texture,
+            )
+            .unwrap()
+        };
 
         let mut frame = pixels.frame_mut().chunks_exact_mut(4);
-        self.draw_frame(&mut frame);
-        pixels.render().expect("could not render");
-    }
-
-    fn draw_frame(&self, frame: &mut ChunksExactMut<u8>) {
         let display = self.display.read().unwrap();
         let luma = self.luma.read().unwrap();
-        let brightness_scale =
-            (u8::MAX as f32) / (u8::from(Brightness::MAX) as f32);
-
-        for tile_y in 0..TILE_HEIGHT {
-            if self.options.spacers && tile_y != 0 {
+        for y in 0..PIXEL_HEIGHT {
+            if self.cli.spacers && y != 0 && y % TILE_SIZE == 0 {
                 // cannot just frame.skip(PIXEL_WIDTH as usize * SPACER_HEIGHT as usize) because of typing
                 for _ in 0..PIXEL_WIDTH * SPACER_HEIGHT {
                     frame.next().unwrap();
                 }
             }
 
-            let start_y = tile_y * TILE_SIZE;
-            for y in start_y..start_y + TILE_SIZE {
-                for tile_x in 0..TILE_WIDTH {
-                    let brightness = u8::from(luma.get(tile_x, tile_y));
-                    let brightness =
-                        (brightness_scale * brightness as f32) as u8;
-                    let on_color = self.get_on_color(brightness);
-                    let start_x = tile_x * TILE_SIZE;
-                    for x in start_x..start_x + TILE_SIZE {
-                        let color = if display.get(x, y) {
-                            on_color
-                        } else {
-                            OFF_COLOR
-                        };
-                        let pixel = frame.next().unwrap();
-                        pixel.copy_from_slice(&color);
-                    }
-                }
+            for x in 0..PIXEL_WIDTH {
+                let is_set = display.get(x, y);
+                let brightness: u8 =
+                    luma.get(x / TILE_SIZE, y / TILE_SIZE).into();
+                let max_brightness: u8 = Brightness::MAX.into();
+                let scale: f32 = (u8::MAX as f32) / (max_brightness as f32);
+
+                let brightness = (scale * brightness as f32) as u8;
+
+                let color = if is_set {
+                    [
+                        if self.cli.red { brightness } else { 0u8 },
+                        if self.cli.green { brightness } else { 0u8 },
+                        if self.cli.blue { brightness } else { 0u8 },
+                        255,
+                    ]
+                } else {
+                    [0u8, 0, 0, 255]
+                };
+
+                let pixel = frame.next().unwrap();
+                pixel.copy_from_slice(&color);
             }
         }
-    }
 
-    fn get_on_color(&self, brightness: u8) -> [u8; 4] {
-        [
-            if self.options.red { brightness } else { 0u8 },
-            if self.options.green { brightness } else { 0u8 },
-            if self.options.blue { brightness } else { 0u8 },
-            255,
-        ]
-    }
-
-    fn get_logical_size(spacers: bool) -> LogicalSize<u16> {
-        let height = if spacers {
-            PIXEL_HEIGHT_WITH_SPACERS
-        } else {
-            PIXEL_HEIGHT
-        };
-        LogicalSize::new(PIXEL_WIDTH as u16, height as u16)
+        pixels.render().expect("could not render");
     }
 }
 
-impl ApplicationHandler<AppEvents> for Gui<'_> {
+impl ApplicationHandler<AppEvents> for App<'_> {
     fn resumed(&mut self, event_loop: &ActiveEventLoop) {
         let attributes = Window::default_attributes()
             .with_title("servicepoint-simulator")

src/main.rs

@@ -1,47 +1,75 @@
 #![deny(clippy::all)]
 
-use crate::font_renderer::FontRenderer8x8;
-use crate::{
-    execute_command::{CommandExecutor, ExecutionResult},
-    gui::{AppEvents, Gui},
-};
-use clap::Parser;
-use cli::Cli;
-use log::{error, info, warn, LevelFilter};
-use servicepoint::*;
 use std::io::ErrorKind;
 use std::net::UdpSocket;
 use std::sync::{mpsc, RwLock};
 use std::time::Duration;
-use winit::event_loop::{ControlFlow, EventLoop, EventLoopProxy};
 
-mod cli;
-mod cp437_font;
+use clap::Parser;
+use log::{info, warn, LevelFilter};
+use servicepoint::*;
+use winit::event_loop::{ControlFlow, EventLoop};
+
+use crate::execute_command::execute_command;
+use crate::font::Cp437Font;
+use crate::font_renderer::FontRenderer8x8;
+use crate::gui::{App, AppEvents};
+
 mod execute_command;
+mod font;
 mod font_renderer;
 mod gui;
 
-const BUF_SIZE: usize = 8985;
+#[derive(Parser, Debug)]
+struct Cli {
+    #[arg(long, default_value = "0.0.0.0:2342")]
+    bind: String,
+    #[arg(short, long, default_value_t = false)]
+    spacers: bool,
+    #[arg(short, long, default_value_t = false)]
+    red: bool,
+    #[arg(short, long, default_value_t = false)]
+    green: bool,
+    #[arg(short, long, default_value_t = false)]
+    blue: bool,
+}
 
 fn main() {
+    env_logger::builder()
+        .filter_level(LevelFilter::Info)
+        .parse_default_env()
+        .init();
+
     let mut cli = Cli::parse();
-    if !(cli.gui.red || cli.gui.blue || cli.gui.green) {
-        cli.gui.green = true;
+    if !(cli.red || cli.blue || cli.green) {
+        cli.green = true;
     }
 
-    init_logging(cli.verbose);
     info!("starting with args: {:?}", &cli);
-
     let socket = UdpSocket::bind(&cli.bind).expect("could not bind socket");
     socket
         .set_nonblocking(true)
         .expect("could not enter non blocking mode");
 
     let display = RwLock::new(Bitmap::new(PIXEL_WIDTH, PIXEL_HEIGHT));
-    let luma = RwLock::new(BrightnessGrid::new(TILE_WIDTH, TILE_HEIGHT));
 
+    let mut luma = BrightnessGrid::new(TILE_WIDTH, TILE_HEIGHT);
+    luma.fill(Brightness::MAX);
+    let luma = RwLock::new(luma);
+
+    run(&display, &luma, socket, Cp437Font::default(), &cli);
+}
+
+fn run(
+    display_ref: &RwLock<Bitmap>,
+    luma_ref: &RwLock<BrightnessGrid>,
+    socket: UdpSocket,
+    cp437_font: Cp437Font,
+    cli: &Cli,
+) {
     let (stop_udp_tx, stop_udp_rx) = mpsc::channel();
-    let mut gui = Gui::new(&display, &luma, stop_udp_tx, cli.gui);
+
+    let mut app = App::new(display_ref, luma_ref, stop_udp_tx, cli);
 
     let event_loop = EventLoop::with_user_event()
         .build()
@@ -49,94 +77,63 @@ fn main() {
     event_loop.set_control_flow(ControlFlow::Wait);
 
     let event_proxy = event_loop.create_proxy();
-    let font_renderer = cli
-        .font
-        .map(move |font| FontRenderer8x8::from_name(font))
-        .unwrap_or_else(move || FontRenderer8x8::default());
-    let command_executor = CommandExecutor::new(&display, &luma, font_renderer);
 
     std::thread::scope(move |scope| {
-        scope.spawn(move || {
-            let mut buf = [0; BUF_SIZE];
+        let udp_thread = scope.spawn(move || {
+            let mut buf = [0; 8985];
+            let utf8_font = FontRenderer8x8::default();
+
             while stop_udp_rx.try_recv().is_err() {
-                receive_into_buf(&socket, &mut buf)
-                    .and_then(move |amount| command_from_slice(&buf[..amount]))
-                    .map(|cmd| {
-                        handle_command(&event_proxy, &command_executor, cmd)
-                    });
+                let (amount, _) = match socket.recv_from(&mut buf) {
+                    Err(err) if err.kind() == ErrorKind::WouldBlock => {
+                        std::thread::sleep(Duration::from_millis(1));
+                        continue;
+                    }
+                    Ok(result) => result,
+                    other => other.unwrap(),
+                };
+
+                if amount == buf.len() {
+                    warn!(
+                        "the received package may have been truncated to a length of {}",
+                        amount
+                    );
+                }
+
+                let package = match servicepoint::Packet::try_from(&buf[..amount]) {
+                    Err(_) => {
+                        warn!("could not load packet with length {amount} into header");
+                        continue;
+                    }
+                    Ok(package) => package,
+                };
+
+                let command = match Command::try_from(package) {
+                    Err(err) => {
+                        warn!("could not read command for packet: {:?}", err);
+                        continue;
+                    }
+                    Ok(val) => val,
+                };
+
+                if !execute_command(command, &cp437_font, &utf8_font, display_ref, luma_ref) {
+                    // hard reset
+                    event_proxy
+                        .send_event(AppEvents::UdpThreadClosed)
+                        .expect("could not send close event");
+                    break;
+                }
+
+                event_proxy
+                    .send_event(AppEvents::UdpPacketHandled)
+                    .expect("could not send packet handled event");
             }
         });
+
         event_loop
-            .run_app(&mut gui)
+            .run_app(&mut app)
             .expect("could not run event loop");
+
+        udp_thread.join().expect("could not join udp thread");
     });
 }
-
-fn handle_command(
-    event_proxy: &EventLoopProxy<AppEvents>,
-    command_executor: &CommandExecutor,
-    command: Command,
-) {
-    match command_executor.execute(command) {
-        ExecutionResult::Success => {
-            event_proxy
-                .send_event(AppEvents::UdpPacketHandled)
-                .expect("could not send packet handled event");
-        }
-        ExecutionResult::Failure => {
-            error!("failed to execute command");
-        }
-        ExecutionResult::Shutdown => {
-            event_proxy
-                .send_event(AppEvents::UdpThreadClosed)
-                .expect("could not send close event");
-        }
-    }
-}
-
-fn init_logging(debug: bool) {
-    let filter = if debug {
-        LevelFilter::Debug
-    } else {
-        LevelFilter::Info
-    };
-    env_logger::builder()
-        .filter_level(filter)
-        .parse_default_env()
-        .init();
-}
-
-fn command_from_slice(slice: &[u8]) -> Option<Command> {
-    let packet = servicepoint::Packet::try_from(slice)
-        .inspect_err(|_| {
-            warn!("could not load packet with length {}", slice.len())
-        })
-        .ok()?;
-    Command::try_from(packet)
-        .inspect_err(move |err| {
-            warn!("could not read command for packet: {:?}", err)
-        })
-        .ok()
-}
-
-fn receive_into_buf(
-    socket: &UdpSocket,
-    buf: &mut [u8; BUF_SIZE],
-) -> Option<usize> {
-    let (amount, _) = match socket.recv_from(buf) {
-        Err(err) if err.kind() == ErrorKind::WouldBlock => {
-            std::thread::sleep(Duration::from_millis(1));
-            return None;
-        }
-        Ok(result) => result,
-        other => other.unwrap(),
-    };
-
-    if amount == buf.len() {
-        warn!(
-            "the received package may have been truncated to a length of {}",
-            amount
-        );
-    }
-    Some(amount)
-}