From 0cbb53b8131d52cfd0960ad0e1e18460d53669f9 Mon Sep 17 00:00:00 2001
From: Matthew Wilding <mbwilding@gmail.com>
Date: Fri, 15 Dec 2023 22:17:41 +0800
Subject: [PATCH 01/39] Init

---
 .run/Debug.run.xml                      |   2 +-
 Cargo.toml                              |   1 +
 common/src/app.rs                       |  10 +-
 common/src/config.rs                    |  14 +-
 common/src/layer.rs                     |   3 +-
 dygma-layer-switcher-gui/Cargo.toml     |  17 +++
 dygma-layer-switcher-gui/src/app.rs     | 168 ++++++++++++++++++++++++
 dygma-layer-switcher-gui/src/main.rs    |  23 ++++
 dygma-layer-switcher-gui/src/structs.rs |  29 ++++
 windows/src/collection.rs               |   2 +-
 10 files changed, 253 insertions(+), 16 deletions(-)
 create mode 100644 dygma-layer-switcher-gui/Cargo.toml
 create mode 100644 dygma-layer-switcher-gui/src/app.rs
 create mode 100644 dygma-layer-switcher-gui/src/main.rs
 create mode 100644 dygma-layer-switcher-gui/src/structs.rs

diff --git a/.run/Debug.run.xml b/.run/Debug.run.xml
index 15fd48d..8b34a94 100644
--- a/.run/Debug.run.xml
+++ b/.run/Debug.run.xml
@@ -1,6 +1,6 @@
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="Debug" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
-    <option name="command" value="run --features no-admin" />
+    <option name="command" value="run --bin dygma-layer-switcher --features no-admin" />
     <option name="workingDirectory" value="file://$PROJECT_DIR$" />
     <option name="emulateTerminal" value="true" />
     <option name="channel" value="DEFAULT" />
diff --git a/Cargo.toml b/Cargo.toml
index 3f6ea2a..cd0925c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -2,6 +2,7 @@
 resolver = "2"
 members = [
     "dygma-layer-switcher",
+    "dygma-layer-switcher-gui",
     "common",
     "windows",
 ]
diff --git a/common/src/app.rs b/common/src/app.rs
index efc192e..e58309a 100644
--- a/common/src/app.rs
+++ b/common/src/app.rs
@@ -1,19 +1,13 @@
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Default, Clone, Deserialize, Serialize)]
-pub struct AppDetails {
-    pub window: Option<String>,
-    pub process: Option<String>,
-}
-
 #[derive(Default, Debug, Clone, Deserialize, Serialize)]
 pub struct Layer {
     pub layer: u8,
-    pub apps: Vec<AppConfig>,
+    pub apps: Vec<App>,
 }
 
 #[derive(Default, Debug, Clone, Deserialize, Serialize)]
-pub struct AppConfig {
+pub struct App {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub window: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
diff --git a/common/src/config.rs b/common/src/config.rs
index 471b1d2..28cc0f0 100644
--- a/common/src/config.rs
+++ b/common/src/config.rs
@@ -1,4 +1,4 @@
-use crate::app::{AppConfig, AppDetails, Layer, Parent};
+use crate::app::{App, Layer, Parent};
 use serde::{Deserialize, Serialize};
 use std::fs::File;
 use std::io;
@@ -16,6 +16,12 @@ pub struct Config {
     pub mappings: Option<Vec<Layer>>,
 }
 
+#[derive(Debug, Default, Clone, Deserialize, Serialize)]
+pub struct AppDetails {
+    pub window: Option<String>,
+    pub process: Option<String>,
+}
+
 impl Default for Config {
     fn default() -> Self {
         let focus = dygma_focus::Focus::default();
@@ -188,7 +194,7 @@ impl Config {
         level: usize,
     ) -> Option<u8>
     where
-        F: Fn(&AppConfig) -> &Option<Parent> + Copy,
+        F: Fn(&App) -> &Option<Parent> + Copy,
     {
         if let Some(parent_pid) = proc.parent() {
             if let Some(parent_proc) = sys.processes().get(&parent_pid) {
@@ -219,7 +225,7 @@ impl Config {
     fn match_property_opt_parent<T, F>(&self, app_property: T, mapping_property: F) -> Option<u8>
     where
         T: AsRef<str>,
-        F: Fn(&AppConfig) -> &Option<Parent>,
+        F: Fn(&App) -> &Option<Parent>,
     {
         let app_prop = app_property.as_ref().to_lowercase();
 
@@ -239,7 +245,7 @@ impl Config {
     fn match_property_opt_string<T, F>(&self, app_property: T, mapping_property: F) -> Option<u8>
     where
         T: AsRef<str>,
-        F: Fn(&AppConfig) -> &Option<String>,
+        F: Fn(&App) -> &Option<String>,
     {
         let app_prop = app_property.as_ref().to_lowercase();
 
diff --git a/common/src/layer.rs b/common/src/layer.rs
index 5974e0f..3e67565 100644
--- a/common/src/layer.rs
+++ b/common/src/layer.rs
@@ -1,5 +1,4 @@
-use crate::app::AppDetails;
-use crate::config::Config;
+use crate::config::{AppDetails, Config};
 use tracing::{debug, error, info};
 
 pub fn process(app_details: &AppDetails) {
diff --git a/dygma-layer-switcher-gui/Cargo.toml b/dygma-layer-switcher-gui/Cargo.toml
new file mode 100644
index 0000000..3983745
--- /dev/null
+++ b/dygma-layer-switcher-gui/Cargo.toml
@@ -0,0 +1,17 @@
+[package]
+name = "dygma-layer-switcher-gui"
+version = "0.1.0"
+edition = "2021"
+authors = ["Matthew Wilding <mbwilding@gmail.com>"]
+
+[dependencies]
+eframe = { version = "0.24", default-features = false, features = [
+    "default_fonts",
+    "wgpu",
+    "persistence",
+] }
+serde = { version = "1.0", features = ["derive"] }
+
+#tracing = "0.1"
+#tracing-appender = "0.2"
+#tracing-subscriber = "0.3"
diff --git a/dygma-layer-switcher-gui/src/app.rs b/dygma-layer-switcher-gui/src/app.rs
new file mode 100644
index 0000000..e672e84
--- /dev/null
+++ b/dygma-layer-switcher-gui/src/app.rs
@@ -0,0 +1,168 @@
+use crate::structs::{App, Layer, Mode, Parent};
+use eframe::egui;
+use eframe::egui::{CentralPanel, Context, Slider};
+use serde::{Deserialize, Serialize};
+use std::collections::BTreeMap;
+
+const MAX_LAYERS: u8 = 10;
+const DEFAULT_TEXT: &str = "Right click to edit";
+
+#[derive(Deserialize, Serialize)]
+#[serde(default)]
+pub struct DygmaLayerSwitcher {
+    pub logging: bool,
+    pub port: String,
+    pub base_layer: u8,
+    pub mappings: BTreeMap<u8, Layer>,
+}
+
+impl Default for DygmaLayerSwitcher {
+    fn default() -> Self {
+        Self {
+            logging: false,
+            port: String::new(),
+            base_layer: 1,
+            mappings: (0..MAX_LAYERS)
+                .map(|i| {
+                    (
+                        i,
+                        Layer {
+                            name: format!("Layer {}", i + 1),
+                            apps: vec![],
+                            is_being_renamed: false,
+                        },
+                    )
+                })
+                .collect::<BTreeMap<u8, Layer>>(),
+        }
+    }
+}
+
+impl DygmaLayerSwitcher {
+    pub fn new(cc: &eframe::CreationContext<'_>) -> Self {
+        // This is also where you can customize the look and feel of egui using
+        // `cc.egui_ctx.set_visuals` and `cc.egui_ctx.set_fonts`.
+
+        if let Some(storage) = cc.storage {
+            return eframe::get_value(storage, eframe::APP_KEY).unwrap_or_default();
+        }
+
+        Default::default()
+    }
+}
+
+impl eframe::App for DygmaLayerSwitcher {
+    fn update(&mut self, ctx: &Context, _frame: &mut eframe::Frame) {
+        CentralPanel::default().show(ctx, |ui| {
+            ui.heading("Dygma Layer Switcher");
+
+            ui.separator();
+
+            ui.horizontal(|ui| {
+                ui.label("Logging");
+                ui.checkbox(&mut self.logging, "");
+            });
+
+            ui.separator();
+
+            ui.horizontal(|ui| {
+                ui.label("Port");
+                ui.text_edit_singleline(&mut self.port);
+            });
+
+            ui.separator();
+
+            ui.horizontal(|ui| {
+                ui.label("Base Layer");
+                ui.add(Slider::new(&mut self.base_layer, 1..=MAX_LAYERS - 1).trailing_fill(true));
+            });
+
+            ui.separator();
+
+            for (_index, layer) in self.mappings.iter_mut() {
+                let mut rename_layer = false;
+                let mut add_window = false;
+                let mut add_process = false;
+                let mut add_parent = false;
+
+                ui.horizontal(|ui| {
+                    if layer.is_being_renamed {
+                        let focus_lost = ui.text_edit_singleline(&mut layer.name).lost_focus();
+                        let enter_pressed = ui.input(|i| i.key_pressed(egui::Key::Enter));
+                        if focus_lost && enter_pressed {
+                            layer.is_being_renamed = false;
+                        }
+                    } else {
+                        let collapsing_response = ui
+                            .collapsing(&layer.name, |ui| {
+                                ui.horizontal(|ui| {
+                                    if ui.button("Add Window").clicked() {
+                                        add_window = true;
+                                    }
+                                    if ui.button("Add Process").clicked() {
+                                        add_process = true;
+                                    }
+                                    if ui.button("Add Parent").clicked() {
+                                        add_parent = true;
+                                    }
+                                });
+
+                                layer.apps.iter_mut().for_each(|app| match &mut app.mode {
+                                    Mode::Window(window) => {
+                                        ui.horizontal(|ui| {
+                                            ui.checkbox(&mut app.is_enabled, "");
+                                            ui.label(format!("Window: {:?}", window));
+                                        });
+                                    }
+                                    Mode::Process(process) => {
+                                        ui.label(format!("Process: {}", process));
+                                    }
+                                    Mode::Parent(parent) => {
+                                        ui.label(format!("Parent: {}", parent.process));
+                                        parent.excludes.iter().for_each(|exclude| {
+                                            ui.label(format!("Exclude: {}", exclude));
+                                        });
+                                    }
+                                });
+                            })
+                            .header_response;
+
+                        rename_layer = collapsing_response.secondary_clicked();
+                    }
+                });
+
+                if rename_layer {
+                    layer.is_being_renamed = true;
+                }
+
+                if add_window {
+                    layer.apps.push(App {
+                        mode: Mode::Window(DEFAULT_TEXT.to_string()),
+                        is_enabled: true,
+                    });
+                }
+
+                if add_process {
+                    layer.apps.push(App {
+                        mode: Mode::Process(DEFAULT_TEXT.to_string()),
+                        is_enabled: true,
+                    });
+                }
+
+                if add_parent {
+                    layer.apps.push(App {
+                        mode: Mode::Parent(Parent {
+                            process: DEFAULT_TEXT.to_string(),
+                            excludes: vec![],
+                        }),
+                        is_enabled: true,
+                    });
+                }
+            }
+        });
+    }
+
+    fn save(&mut self, storage: &mut dyn eframe::Storage) {
+        eframe::set_value(storage, eframe::APP_KEY, self);
+    }
+}
diff --git a/dygma-layer-switcher-gui/src/main.rs b/dygma-layer-switcher-gui/src/main.rs
new file mode 100644
index 0000000..92573e7
--- /dev/null
+++ b/dygma-layer-switcher-gui/src/main.rs
@@ -0,0 +1,23 @@
+extern crate core;
+
+mod app;
+mod structs;
+
+pub fn main() {
+    eframe::run_native(
+        "Dygma Layer Switcher",
+        eframe::NativeOptions {
+            // viewport: Default::default(),
+            vsync: true,
+            follow_system_theme: true,
+            default_theme: eframe::Theme::Dark,
+            // run_and_return: false,
+            // event_loop_builder: None,
+            centered: true,
+            persist_window: true,
+            ..Default::default()
+        },
+        Box::new(|cc| Box::new(app::DygmaLayerSwitcher::new(cc))),
+    )
+    .unwrap();
+}
diff --git a/dygma-layer-switcher-gui/src/structs.rs b/dygma-layer-switcher-gui/src/structs.rs
new file mode 100644
index 0000000..2d2c14c
--- /dev/null
+++ b/dygma-layer-switcher-gui/src/structs.rs
@@ -0,0 +1,29 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize)]
+pub struct Layer {
+    pub name: String,
+    pub apps: Vec<App>,
+
+    #[serde(skip)]
+    pub is_being_renamed: bool,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct App {
+    pub mode: Mode,
+    pub is_enabled: bool,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub enum Mode {
+    Window(String),
+    Process(String),
+    Parent(Parent),
+}
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize)]
+pub struct Parent {
+    pub process: String,
+    pub excludes: Vec<String>,
+}
diff --git a/windows/src/collection.rs b/windows/src/collection.rs
index e143ed3..72068dd 100644
--- a/windows/src/collection.rs
+++ b/windows/src/collection.rs
@@ -1,4 +1,4 @@
-use common::app::AppDetails;
+use common::config::AppDetails;
 use std::path::Path;
 use tracing::{error, trace};
 use windows::Win32::{

From 26cc4813adbfc2db737ddea02dcf7dfa7b1e4d33 Mon Sep 17 00:00:00 2001
From: Matthew Wilding <mbwilding@gmail.com>
Date: Fri, 15 Dec 2023 22:54:39 +0800
Subject: [PATCH 02/39] Restructure

---
 dygma-layer-switcher-gui/src/app.rs       | 81 ++++++++++++++---------
 dygma-layer-switcher-gui/src/main.rs      |  1 +
 dygma-layer-switcher-gui/src/templates.rs | 11 +++
 3 files changed, 61 insertions(+), 32 deletions(-)
 create mode 100644 dygma-layer-switcher-gui/src/templates.rs

diff --git a/dygma-layer-switcher-gui/src/app.rs b/dygma-layer-switcher-gui/src/app.rs
index e672e84..b3ae42a 100644
--- a/dygma-layer-switcher-gui/src/app.rs
+++ b/dygma-layer-switcher-gui/src/app.rs
@@ -1,11 +1,12 @@
-use crate::structs::{App, Layer, Mode, Parent};
-use eframe::egui;
-use eframe::egui::{CentralPanel, Context, Slider};
+use crate::structs::*;
+use crate::templates;
+use eframe::egui::{CentralPanel, Context, Slider, TopBottomPanel};
+use eframe::{egui, Frame, Storage};
 use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
 
 const MAX_LAYERS: u8 = 10;
-const DEFAULT_TEXT: &str = "Right click to edit";
+const EDIT_TEXT: &str = "Placeholder";
 
 #[derive(Deserialize, Serialize)]
 #[serde(default)]
@@ -14,6 +15,9 @@ pub struct DygmaLayerSwitcher {
     pub port: String,
     pub base_layer: u8,
     pub mappings: BTreeMap<u8, Layer>,
+
+    #[serde(skip)]
+    pub editing_port: bool,
 }
 
 impl Default for DygmaLayerSwitcher {
@@ -34,6 +38,8 @@ impl Default for DygmaLayerSwitcher {
                     )
                 })
                 .collect::<BTreeMap<u8, Layer>>(),
+
+            editing_port: false,
         }
     }
 }
@@ -49,36 +55,40 @@ impl DygmaLayerSwitcher {
 
         Default::default()
     }
-}
-
-impl eframe::App for DygmaLayerSwitcher {
-    fn update(&mut self, ctx: &Context, _frame: &mut eframe::Frame) {
-        CentralPanel::default().show(ctx, |ui| {
-            ui.heading("Dygma Layer Switcher");
 
-            ui.separator();
-
-            ui.horizontal(|ui| {
-                ui.label("Logging");
-                ui.checkbox(&mut self.logging, "");
-            });
-
-            ui.separator();
+    fn logging_control(&mut self, ui: &mut egui::Ui) {
+        ui.horizontal(|ui| {
+            ui.label("Logging");
+            ui.checkbox(&mut self.logging, "");
+        });
+    }
 
-            ui.horizontal(|ui| {
-                ui.label("Port");
-                ui.text_edit_singleline(&mut self.port);
-            });
+    fn port_control(&mut self, ui: &mut egui::Ui) {
+        ui.horizontal(|ui| {
+            ui.label("Port");
+            templates::editable_label(ui, &mut self.port, &mut self.editing_port);
+        });
+    }
 
-            ui.separator();
+    fn base_layer_control(&mut self, ui: &mut egui::Ui) {
+        ui.horizontal(|ui| {
+            ui.label("Base Layer");
+            ui.add(Slider::new(&mut self.base_layer, 1..=MAX_LAYERS - 1).trailing_fill(true));
+        });
+    }
 
-            ui.horizontal(|ui| {
-                ui.label("Base Layer");
-                ui.add(Slider::new(&mut self.base_layer, 1..=MAX_LAYERS - 1).trailing_fill(true));
+    fn top_panel(&mut self, ctx: &Context) {
+        TopBottomPanel::top("top_panel").show(ctx, |ui| {
+            ui.collapsing("Settings", |ui| {
+                self.logging_control(ui);
+                self.port_control(ui);
+                self.base_layer_control(ui);
             });
+        });
+    }
 
-            ui.separator();
-
+    fn central_panel(&mut self, ctx: &Context) {
+        CentralPanel::default().show(ctx, |ui| {
             for (_index, layer) in self.mappings.iter_mut() {
                 let mut rename_layer = false;
                 let mut add_window = false;
@@ -137,14 +147,14 @@ impl eframe::App for DygmaLayerSwitcher {
 
                 if add_window {
                     layer.apps.push(App {
-                        mode: Mode::Window(DEFAULT_TEXT.to_string()),
+                        mode: Mode::Window(EDIT_TEXT.to_string()),
                         is_enabled: true,
                     });
                 }
 
                 if add_process {
                     layer.apps.push(App {
-                        mode: Mode::Process(DEFAULT_TEXT.to_string()),
+                        mode: Mode::Process(EDIT_TEXT.to_string()),
                         is_enabled: true,
                     });
                 }
@@ -152,7 +162,7 @@ impl eframe::App for DygmaLayerSwitcher {
                 if add_parent {
                     layer.apps.push(App {
                         mode: Mode::Parent(Parent {
-                            process: DEFAULT_TEXT.to_string(),
+                            process: EDIT_TEXT.to_string(),
                             excludes: vec![],
                         }),
                         is_enabled: true,
@@ -161,8 +171,15 @@ impl eframe::App for DygmaLayerSwitcher {
             }
         });
     }
+}
+
+impl eframe::App for DygmaLayerSwitcher {
+    fn update(&mut self, ctx: &Context, _frame: &mut Frame) {
+        self.top_panel(ctx);
+        self.central_panel(ctx);
+    }
 
-    fn save(&mut self, storage: &mut dyn eframe::Storage) {
+    fn save(&mut self, storage: &mut dyn Storage) {
         eframe::set_value(storage, eframe::APP_KEY, self);
     }
 }
diff --git a/dygma-layer-switcher-gui/src/main.rs b/dygma-layer-switcher-gui/src/main.rs
index 92573e7..ea0b61a 100644
--- a/dygma-layer-switcher-gui/src/main.rs
+++ b/dygma-layer-switcher-gui/src/main.rs
@@ -2,6 +2,7 @@ extern crate core;
 
 mod app;
 mod structs;
+mod templates;
 
 pub fn main() {
     eframe::run_native(
diff --git a/dygma-layer-switcher-gui/src/templates.rs b/dygma-layer-switcher-gui/src/templates.rs
new file mode 100644
index 0000000..10cf6b6
--- /dev/null
+++ b/dygma-layer-switcher-gui/src/templates.rs
@@ -0,0 +1,11 @@
+use eframe::egui;
+
+pub fn editable_label(ui: &mut egui::Ui, value: &mut String, editing: &mut bool) {
+    if *editing {
+        if ui.text_edit_singleline(value).lost_focus() {
+            *editing = false;
+        }
+    } else if ui.button(value.as_str()).clicked() {
+        *editing = true;
+    }
+}

From 4f9a690879b5e4e4e1a091a9c0286c6581a20ca3 Mon Sep 17 00:00:00 2001
From: Matthew Wilding <mbwilding@gmail.com>
Date: Fri, 15 Dec 2023 23:39:12 +0800
Subject: [PATCH 03/39] Update

---
 dygma-layer-switcher-gui/src/app.rs | 82 +++++++++++++----------------
 1 file changed, 37 insertions(+), 45 deletions(-)

diff --git a/dygma-layer-switcher-gui/src/app.rs b/dygma-layer-switcher-gui/src/app.rs
index b3ae42a..c16a481 100644
--- a/dygma-layer-switcher-gui/src/app.rs
+++ b/dygma-layer-switcher-gui/src/app.rs
@@ -1,6 +1,6 @@
 use crate::structs::*;
 use crate::templates;
-use eframe::egui::{CentralPanel, Context, Slider, TopBottomPanel};
+use eframe::egui::{CentralPanel, Context, DragValue, TopBottomPanel};
 use eframe::{egui, Frame, Storage};
 use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
@@ -73,7 +73,7 @@ impl DygmaLayerSwitcher {
     fn base_layer_control(&mut self, ui: &mut egui::Ui) {
         ui.horizontal(|ui| {
             ui.label("Base Layer");
-            ui.add(Slider::new(&mut self.base_layer, 1..=MAX_LAYERS - 1).trailing_fill(true));
+            ui.add(DragValue::new(&mut self.base_layer));
         });
     }
 
@@ -96,49 +96,41 @@ impl DygmaLayerSwitcher {
                 let mut add_parent = false;
 
                 ui.horizontal(|ui| {
-                    if layer.is_being_renamed {
-                        let focus_lost = ui.text_edit_singleline(&mut layer.name).lost_focus();
-                        let enter_pressed = ui.input(|i| i.key_pressed(egui::Key::Enter));
-                        if focus_lost && enter_pressed {
-                            layer.is_being_renamed = false;
-                        }
-                    } else {
-                        let collapsing_response = ui
-                            .collapsing(&layer.name, |ui| {
-                                ui.horizontal(|ui| {
-                                    if ui.button("Add Window").clicked() {
-                                        add_window = true;
-                                    }
-                                    if ui.button("Add Process").clicked() {
-                                        add_process = true;
-                                    }
-                                    if ui.button("Add Parent").clicked() {
-                                        add_parent = true;
-                                    }
-                                });
-
-                                layer.apps.iter_mut().for_each(|app| match &mut app.mode {
-                                    Mode::Window(window) => {
-                                        ui.horizontal(|ui| {
-                                            ui.checkbox(&mut app.is_enabled, "");
-                                            ui.label(format!("Window: {:?}", window));
-                                        });
-                                    }
-                                    Mode::Process(process) => {
-                                        ui.label(format!("Process: {}", process));
-                                    }
-                                    Mode::Parent(parent) => {
-                                        ui.label(format!("Parent: {}", parent.process));
-                                        parent.excludes.iter().for_each(|exclude| {
-                                            ui.label(format!("Exclude: {}", exclude));
-                                        });
-                                    }
-                                });
-                            })
-                            .header_response;
-
-                        rename_layer = collapsing_response.secondary_clicked();
-                    }
+                    let collapsing_response = ui
+                        .collapsing(&layer.name, |ui| {
+                            ui.horizontal(|ui| {
+                                if ui.button("Add Window").clicked() {
+                                    add_window = true;
+                                }
+                                if ui.button("Add Process").clicked() {
+                                    add_process = true;
+                                }
+                                if ui.button("Add Parent").clicked() {
+                                    add_parent = true;
+                                }
+                            });
+
+                            layer.apps.iter_mut().for_each(|app| match &mut app.mode {
+                                Mode::Window(window) => {
+                                    ui.horizontal(|ui| {
+                                        ui.checkbox(&mut app.is_enabled, "");
+                                        ui.label(format!("Window: {:?}", window));
+                                    });
+                                }
+                                Mode::Process(process) => {
+                                    ui.label(format!("Process: {}", process));
+                                }
+                                Mode::Parent(parent) => {
+                                    ui.label(format!("Parent: {}", parent.process));
+                                    parent.excludes.iter().for_each(|exclude| {
+                                        ui.label(format!("Exclude: {}", exclude));
+                                    });
+                                }
+                            });
+                        })
+                        .header_response;
+
+                    rename_layer = collapsing_response.secondary_clicked();
                 });
 
                 if rename_layer {

From b68eff2c8234c245ae1fe8efbfe9fd6775683c84 Mon Sep 17 00:00:00 2001
From: Matthew Wilding <mbwilding@gmail.com>
Date: Sat, 16 Dec 2023 00:28:38 +0800
Subject: [PATCH 04/39] Update

---
 dygma-layer-switcher-gui/src/app.rs       | 123 ++++++++++------------
 dygma-layer-switcher-gui/src/templates.rs |  23 ++++
 2 files changed, 81 insertions(+), 65 deletions(-)

diff --git a/dygma-layer-switcher-gui/src/app.rs b/dygma-layer-switcher-gui/src/app.rs
index c16a481..3d46904 100644
--- a/dygma-layer-switcher-gui/src/app.rs
+++ b/dygma-layer-switcher-gui/src/app.rs
@@ -90,76 +90,69 @@ impl DygmaLayerSwitcher {
     fn central_panel(&mut self, ctx: &Context) {
         CentralPanel::default().show(ctx, |ui| {
             for (_index, layer) in self.mappings.iter_mut() {
-                let mut rename_layer = false;
-                let mut add_window = false;
-                let mut add_process = false;
-                let mut add_parent = false;
-
-                ui.horizontal(|ui| {
-                    let collapsing_response = ui
-                        .collapsing(&layer.name, |ui| {
-                            ui.horizontal(|ui| {
-                                if ui.button("Add Window").clicked() {
-                                    add_window = true;
-                                }
-                                if ui.button("Add Process").clicked() {
-                                    add_process = true;
-                                }
-                                if ui.button("Add Parent").clicked() {
-                                    add_parent = true;
-                                }
-                            });
-
-                            layer.apps.iter_mut().for_each(|app| match &mut app.mode {
-                                Mode::Window(window) => {
+                templates::editable_collapsing(
+                    ui,
+                    &mut layer.name,
+                    &mut layer.is_being_renamed,
+                    |ui| {
+                        ui.horizontal(|ui| {
+                            if ui.button("Add Window").clicked() {
+                                layer.apps.push(App {
+                                    mode: Mode::Window(EDIT_TEXT.to_string()),
+                                    is_enabled: true,
+                                });
+                            }
+                            if ui.button("Add Process").clicked() {
+                                layer.apps.push(App {
+                                    mode: Mode::Process(EDIT_TEXT.to_string()),
+                                    is_enabled: true,
+                                });
+                            }
+                            if ui.button("Add Parent").clicked() {
+                                layer.apps.push(App {
+                                    mode: Mode::Parent(Parent {
+                                        process: EDIT_TEXT.to_string(),
+                                        excludes: vec![],
+                                    }),
+                                    is_enabled: true,
+                                });
+                            }
+                        });
+
+                        layer.apps.iter_mut().for_each(|app| match &mut app.mode {
+                            Mode::Window(window) => {
+                                ui.horizontal(|ui| {
+                                    ui.checkbox(&mut app.is_enabled, "");
                                     ui.horizontal(|ui| {
-                                        ui.checkbox(&mut app.is_enabled, "");
-                                        ui.label(format!("Window: {:?}", window));
+                                        ui.label("Window: ");
+                                        ui.label(window.as_str());
+                                    });
+                                });
+                            }
+                            Mode::Process(process) => {
+                                ui.horizontal(|ui| {
+                                    ui.checkbox(&mut app.is_enabled, "");
+                                    ui.horizontal(|ui| {
+                                        ui.label("Process: ");
+                                        ui.label(process.as_str());
+                                    });
+                                });
+                            }
+                            Mode::Parent(parent) => {
+                                ui.horizontal(|ui| {
+                                    ui.checkbox(&mut app.is_enabled, "");
+                                    ui.horizontal(|ui| {
+                                        ui.label("Parent: ");
+                                        ui.label(&parent.process);
                                     });
-                                }
-                                Mode::Process(process) => {
-                                    ui.label(format!("Process: {}", process));
-                                }
-                                Mode::Parent(parent) => {
-                                    ui.label(format!("Parent: {}", parent.process));
                                     parent.excludes.iter().for_each(|exclude| {
                                         ui.label(format!("Exclude: {}", exclude));
                                     });
-                                }
-                            });
-                        })
-                        .header_response;
-
-                    rename_layer = collapsing_response.secondary_clicked();
-                });
-
-                if rename_layer {
-                    layer.is_being_renamed = true;
-                }
-
-                if add_window {
-                    layer.apps.push(App {
-                        mode: Mode::Window(EDIT_TEXT.to_string()),
-                        is_enabled: true,
-                    });
-                }
-
-                if add_process {
-                    layer.apps.push(App {
-                        mode: Mode::Process(EDIT_TEXT.to_string()),
-                        is_enabled: true,
-                    });
-                }
-
-                if add_parent {
-                    layer.apps.push(App {
-                        mode: Mode::Parent(Parent {
-                            process: EDIT_TEXT.to_string(),
-                            excludes: vec![],
-                        }),
-                        is_enabled: true,
-                    });
-                }
+                                });
+                            }
+                        });
+                    },
+                );
             }
         });
     }
diff --git a/dygma-layer-switcher-gui/src/templates.rs b/dygma-layer-switcher-gui/src/templates.rs
index 10cf6b6..682a675 100644
--- a/dygma-layer-switcher-gui/src/templates.rs
+++ b/dygma-layer-switcher-gui/src/templates.rs
@@ -9,3 +9,26 @@ pub fn editable_label(ui: &mut egui::Ui, value: &mut String, editing: &mut bool)
         *editing = true;
     }
 }
+
+pub fn editable_collapsing<F: FnMut(&mut egui::Ui)>(
+    ui: &mut egui::Ui,
+    value: &mut String,
+    editing: &mut bool,
+    mut content: F,
+) {
+    if *editing {
+        if ui.text_edit_singleline(value).lost_focus() {
+            *editing = false;
+        }
+    } else {
+        let header_response = ui
+            .collapsing(&value.clone(), |ui| {
+                content(ui);
+            })
+            .header_response;
+
+        if header_response.secondary_clicked() {
+            *editing = true;
+        }
+    }
+}

From 18abc7fe638cb02f1055e9c804f1a8d2956a5fc6 Mon Sep 17 00:00:00 2001
From: Matthew Wilding <mbwilding@gmail.com>
Date: Sat, 16 Dec 2023 00:55:45 +0800
Subject: [PATCH 05/39] Progress

---
 dygma-layer-switcher-gui/src/app.rs     | 116 ++++++++++++------------
 dygma-layer-switcher-gui/src/structs.rs |   5 +-
 2 files changed, 64 insertions(+), 57 deletions(-)

diff --git a/dygma-layer-switcher-gui/src/app.rs b/dygma-layer-switcher-gui/src/app.rs
index 3d46904..6337143 100644
--- a/dygma-layer-switcher-gui/src/app.rs
+++ b/dygma-layer-switcher-gui/src/app.rs
@@ -33,7 +33,7 @@ impl Default for DygmaLayerSwitcher {
                         Layer {
                             name: format!("Layer {}", i + 1),
                             apps: vec![],
-                            is_being_renamed: false,
+                            is_editing: false,
                         },
                     )
                 })
@@ -90,69 +90,73 @@ impl DygmaLayerSwitcher {
     fn central_panel(&mut self, ctx: &Context) {
         CentralPanel::default().show(ctx, |ui| {
             for (_index, layer) in self.mappings.iter_mut() {
-                templates::editable_collapsing(
-                    ui,
-                    &mut layer.name,
-                    &mut layer.is_being_renamed,
-                    |ui| {
-                        ui.horizontal(|ui| {
-                            if ui.button("Add Window").clicked() {
-                                layer.apps.push(App {
-                                    mode: Mode::Window(EDIT_TEXT.to_string()),
-                                    is_enabled: true,
-                                });
-                            }
-                            if ui.button("Add Process").clicked() {
-                                layer.apps.push(App {
-                                    mode: Mode::Process(EDIT_TEXT.to_string()),
-                                    is_enabled: true,
-                                });
-                            }
-                            if ui.button("Add Parent").clicked() {
-                                layer.apps.push(App {
-                                    mode: Mode::Parent(Parent {
-                                        process: EDIT_TEXT.to_string(),
-                                        excludes: vec![],
-                                    }),
-                                    is_enabled: true,
-                                });
-                            }
-                        });
-
-                        layer.apps.iter_mut().for_each(|app| match &mut app.mode {
-                            Mode::Window(window) => {
+                templates::editable_collapsing(ui, &mut layer.name, &mut layer.is_editing, |ui| {
+                    ui.horizontal(|ui| {
+                        if ui.button("Add Window").clicked() {
+                            layer.apps.push(App {
+                                mode: Mode::Window(EDIT_TEXT.to_string()),
+                                is_enabled: true,
+                            });
+                        }
+                        if ui.button("Add Process").clicked() {
+                            layer.apps.push(App {
+                                mode: Mode::Process(EDIT_TEXT.to_string()),
+                                is_enabled: true,
+                            });
+                        }
+                        if ui.button("Add Parent").clicked() {
+                            layer.apps.push(App {
+                                mode: Mode::Parent(Parent {
+                                    process: EDIT_TEXT.to_string(),
+                                    excludes: vec![],
+                                    is_editing: false,
+                                }),
+                                is_enabled: true,
+                            });
+                        }
+                    });
+
+                    layer.apps.iter_mut().for_each(|app| match &mut app.mode {
+                        Mode::Window(window) => {
+                            ui.horizontal(|ui| {
+                                ui.checkbox(&mut app.is_enabled, "");
                                 ui.horizontal(|ui| {
-                                    ui.checkbox(&mut app.is_enabled, "");
-                                    ui.horizontal(|ui| {
-                                        ui.label("Window: ");
-                                        ui.label(window.as_str());
-                                    });
+                                    ui.label("Window: ");
+                                    ui.label(window.as_str());
                                 });
-                            }
-                            Mode::Process(process) => {
+                            });
+                        }
+                        Mode::Process(process) => {
+                            ui.horizontal(|ui| {
+                                ui.checkbox(&mut app.is_enabled, "");
                                 ui.horizontal(|ui| {
-                                    ui.checkbox(&mut app.is_enabled, "");
-                                    ui.horizontal(|ui| {
-                                        ui.label("Process: ");
-                                        ui.label(process.as_str());
-                                    });
+                                    ui.label("Process: ");
+                                    ui.label(process.as_str());
                                 });
-                            }
-                            Mode::Parent(parent) => {
+                            });
+                        }
+                        Mode::Parent(parent) => {
+                            ui.horizontal(|ui| {
+                                ui.checkbox(&mut app.is_enabled, "");
                                 ui.horizontal(|ui| {
-                                    ui.checkbox(&mut app.is_enabled, "");
+                                    ui.label("Parent: ");
+                                    ui.label(&parent.process);
+                                });
+
+                                if ui.button("Add Exclude").clicked() {
+                                    parent.excludes.push(EDIT_TEXT.to_string());
+                                }
+
+                                parent.excludes.iter().for_each(|exclude| {
                                     ui.horizontal(|ui| {
-                                        ui.label("Parent: ");
-                                        ui.label(&parent.process);
-                                    });
-                                    parent.excludes.iter().for_each(|exclude| {
-                                        ui.label(format!("Exclude: {}", exclude));
+                                        ui.label("Exclude: ");
+                                        ui.label(exclude);
                                     });
                                 });
-                            }
-                        });
-                    },
-                );
+                            });
+                        }
+                    });
+                });
             }
         });
     }
diff --git a/dygma-layer-switcher-gui/src/structs.rs b/dygma-layer-switcher-gui/src/structs.rs
index 2d2c14c..8b3ce8e 100644
--- a/dygma-layer-switcher-gui/src/structs.rs
+++ b/dygma-layer-switcher-gui/src/structs.rs
@@ -6,7 +6,7 @@ pub struct Layer {
     pub apps: Vec<App>,
 
     #[serde(skip)]
-    pub is_being_renamed: bool,
+    pub is_editing: bool,
 }
 
 #[derive(Debug, Clone, Deserialize, Serialize)]
@@ -26,4 +26,7 @@ pub enum Mode {
 pub struct Parent {
     pub process: String,
     pub excludes: Vec<String>,
+
+    #[serde(skip)]
+    pub is_editing: bool,
 }

From 0c3e4bfc561576666102578a861ea0d9c47b8491 Mon Sep 17 00:00:00 2001
From: Matthew Wilding <mbwilding@gmail.com>
Date: Sat, 16 Dec 2023 01:16:23 +0800
Subject: [PATCH 06/39] Progress

---
 dygma-layer-switcher-gui/src/app.rs     | 80 ++++++++++++++-----------
 dygma-layer-switcher-gui/src/structs.rs | 16 ++++-
 2 files changed, 59 insertions(+), 37 deletions(-)

diff --git a/dygma-layer-switcher-gui/src/app.rs b/dygma-layer-switcher-gui/src/app.rs
index 6337143..a613317 100644
--- a/dygma-layer-switcher-gui/src/app.rs
+++ b/dygma-layer-switcher-gui/src/app.rs
@@ -94,13 +94,19 @@ impl DygmaLayerSwitcher {
                     ui.horizontal(|ui| {
                         if ui.button("Add Window").clicked() {
                             layer.apps.push(App {
-                                mode: Mode::Window(EDIT_TEXT.to_string()),
+                                mode: Mode::Window(Window {
+                                    name: EDIT_TEXT.to_string(),
+                                    is_editing: false,
+                                }),
                                 is_enabled: true,
                             });
                         }
                         if ui.button("Add Process").clicked() {
                             layer.apps.push(App {
-                                mode: Mode::Process(EDIT_TEXT.to_string()),
+                                mode: Mode::Process(Process {
+                                    name: EDIT_TEXT.to_string(),
+                                    is_editing: false,
+                                }),
                                 is_enabled: true,
                             });
                         }
@@ -116,45 +122,49 @@ impl DygmaLayerSwitcher {
                         }
                     });
 
-                    layer.apps.iter_mut().for_each(|app| match &mut app.mode {
-                        Mode::Window(window) => {
-                            ui.horizontal(|ui| {
-                                ui.checkbox(&mut app.is_enabled, "");
+                    ui.collapsing("Windows", |ui| {
+                        layer.apps.iter_mut().for_each(|app| {
+                            if let Mode::Window(window) = &mut app.mode {
                                 ui.horizontal(|ui| {
-                                    ui.label("Window: ");
-                                    ui.label(window.as_str());
+                                    ui.checkbox(&mut app.is_enabled, "");
+                                    templates::editable_label(
+                                        ui,
+                                        &mut window.name,
+                                        &mut window.is_editing,
+                                    );
                                 });
-                            });
-                        }
-                        Mode::Process(process) => {
-                            ui.horizontal(|ui| {
-                                ui.checkbox(&mut app.is_enabled, "");
-                                ui.horizontal(|ui| {
-                                    ui.label("Process: ");
-                                    ui.label(process.as_str());
-                                });
-                            });
-                        }
-                        Mode::Parent(parent) => {
-                            ui.horizontal(|ui| {
-                                ui.checkbox(&mut app.is_enabled, "");
+                            }
+                        });
+                    });
+
+                    ui.collapsing("Processes", |ui| {
+                        layer.apps.iter_mut().for_each(|app| {
+                            if let Mode::Process(process) = &mut app.mode {
                                 ui.horizontal(|ui| {
-                                    ui.label("Parent: ");
-                                    ui.label(&parent.process);
+                                    ui.checkbox(&mut app.is_enabled, "");
+                                    templates::editable_label(
+                                        ui,
+                                        &mut process.name,
+                                        &mut process.is_editing,
+                                    );
                                 });
+                            }
+                        });
+                    });
 
-                                if ui.button("Add Exclude").clicked() {
-                                    parent.excludes.push(EDIT_TEXT.to_string());
-                                }
-
-                                parent.excludes.iter().for_each(|exclude| {
-                                    ui.horizontal(|ui| {
-                                        ui.label("Exclude: ");
-                                        ui.label(exclude);
-                                    });
+                    ui.collapsing("Parents", |ui| {
+                        layer.apps.iter_mut().for_each(|app| {
+                            if let Mode::Parent(parent) = &mut app.mode {
+                                ui.horizontal(|ui| {
+                                    ui.checkbox(&mut app.is_enabled, "");
+                                    templates::editable_label(
+                                        ui,
+                                        &mut parent.process,
+                                        &mut parent.is_editing,
+                                    );
                                 });
-                            });
-                        }
+                            }
+                        });
                     });
                 });
             }
diff --git a/dygma-layer-switcher-gui/src/structs.rs b/dygma-layer-switcher-gui/src/structs.rs
index 8b3ce8e..a759856 100644
--- a/dygma-layer-switcher-gui/src/structs.rs
+++ b/dygma-layer-switcher-gui/src/structs.rs
@@ -17,11 +17,23 @@ pub struct App {
 
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub enum Mode {
-    Window(String),
-    Process(String),
+    Window(Window),
+    Process(Process),
     Parent(Parent),
 }
 
+#[derive(Default, Debug, Clone, Deserialize, Serialize)]
+pub struct Window {
+    pub name: String,
+    pub is_editing: bool,
+}
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize)]
+pub struct Process {
+    pub name: String,
+    pub is_editing: bool,
+}
+
 #[derive(Default, Debug, Clone, Deserialize, Serialize)]
 pub struct Parent {
     pub process: String,

From f29d5ad0dd6bd296dd0805b3f644fde0b4f38d7a Mon Sep 17 00:00:00 2001
From: Matthew Wilding <mbwilding@gmail.com>
Date: Sat, 16 Dec 2023 01:42:07 +0800
Subject: [PATCH 07/39] Progress

---
 dygma-layer-switcher-gui/src/app.rs     | 54 ++++++----------
 dygma-layer-switcher-gui/src/structs.rs | 84 ++++++++++++++++++++++++-
 2 files changed, 102 insertions(+), 36 deletions(-)

diff --git a/dygma-layer-switcher-gui/src/app.rs b/dygma-layer-switcher-gui/src/app.rs
index a613317..c33f239 100644
--- a/dygma-layer-switcher-gui/src/app.rs
+++ b/dygma-layer-switcher-gui/src/app.rs
@@ -6,7 +6,6 @@ use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
 
 const MAX_LAYERS: u8 = 10;
-const EDIT_TEXT: &str = "Placeholder";
 
 #[derive(Deserialize, Serialize)]
 #[serde(default)]
@@ -27,16 +26,7 @@ impl Default for DygmaLayerSwitcher {
             port: String::new(),
             base_layer: 1,
             mappings: (0..MAX_LAYERS)
-                .map(|i| {
-                    (
-                        i,
-                        Layer {
-                            name: format!("Layer {}", i + 1),
-                            apps: vec![],
-                            is_editing: false,
-                        },
-                    )
-                })
+                .map(|i| (i, Layer::new(i)))
                 .collect::<BTreeMap<u8, Layer>>(),
 
             editing_port: false,
@@ -93,32 +83,13 @@ impl DygmaLayerSwitcher {
                 templates::editable_collapsing(ui, &mut layer.name, &mut layer.is_editing, |ui| {
                     ui.horizontal(|ui| {
                         if ui.button("Add Window").clicked() {
-                            layer.apps.push(App {
-                                mode: Mode::Window(Window {
-                                    name: EDIT_TEXT.to_string(),
-                                    is_editing: false,
-                                }),
-                                is_enabled: true,
-                            });
+                            layer.apps.push(App::new_window());
                         }
                         if ui.button("Add Process").clicked() {
-                            layer.apps.push(App {
-                                mode: Mode::Process(Process {
-                                    name: EDIT_TEXT.to_string(),
-                                    is_editing: false,
-                                }),
-                                is_enabled: true,
-                            });
+                            layer.apps.push(App::new_process());
                         }
                         if ui.button("Add Parent").clicked() {
-                            layer.apps.push(App {
-                                mode: Mode::Parent(Parent {
-                                    process: EDIT_TEXT.to_string(),
-                                    excludes: vec![],
-                                    is_editing: false,
-                                }),
-                                is_enabled: true,
-                            });
+                            layer.apps.push(App::new_parent());
                         }
                     });
 
@@ -157,12 +128,27 @@ impl DygmaLayerSwitcher {
                             if let Mode::Parent(parent) = &mut app.mode {
                                 ui.horizontal(|ui| {
                                     ui.checkbox(&mut app.is_enabled, "");
+                                    if ui.button("Add Exclude").clicked() {
+                                        parent.excludes.push(Exclude::new());
+                                    }
                                     templates::editable_label(
                                         ui,
-                                        &mut parent.process,
+                                        &mut parent.name,
                                         &mut parent.is_editing,
                                     );
                                 });
+                                ui.indent("Excludes", |ui| {
+                                    parent.excludes.iter_mut().for_each(|exclude| {
+                                        ui.horizontal(|ui| {
+                                            ui.checkbox(&mut exclude.is_enabled, "");
+                                            templates::editable_label(
+                                                ui,
+                                                &mut exclude.name,
+                                                &mut exclude.is_editing,
+                                            );
+                                        });
+                                    });
+                                });
                             }
                         });
                     });
diff --git a/dygma-layer-switcher-gui/src/structs.rs b/dygma-layer-switcher-gui/src/structs.rs
index a759856..da276e8 100644
--- a/dygma-layer-switcher-gui/src/structs.rs
+++ b/dygma-layer-switcher-gui/src/structs.rs
@@ -9,12 +9,45 @@ pub struct Layer {
     pub is_editing: bool,
 }
 
+impl Layer {
+    pub fn new(layer: u8) -> Self {
+        Self {
+            name: format!("Layer {}", layer + 1),
+            apps: vec![],
+            is_editing: false,
+        }
+    }
+}
+
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct App {
     pub mode: Mode,
     pub is_enabled: bool,
 }
 
+impl App {
+    pub fn new_window() -> Self {
+        Self {
+            mode: Mode::Window(Window::new()),
+            is_enabled: true,
+        }
+    }
+
+    pub fn new_process() -> Self {
+        Self {
+            mode: Mode::Process(Process::new()),
+            is_enabled: true,
+        }
+    }
+
+    pub fn new_parent() -> Self {
+        Self {
+            mode: Mode::Parent(Parent::new()),
+            is_enabled: true,
+        }
+    }
+}
+
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub enum Mode {
     Window(Window),
@@ -28,17 +61,64 @@ pub struct Window {
     pub is_editing: bool,
 }
 
+impl Window {
+    pub fn new() -> Self {
+        Self {
+            name: "Window Placeholder".to_string(),
+            is_editing: false,
+        }
+    }
+}
+
 #[derive(Default, Debug, Clone, Deserialize, Serialize)]
 pub struct Process {
     pub name: String,
     pub is_editing: bool,
 }
 
+impl Process {
+    pub fn new() -> Self {
+        Self {
+            name: "Process Placeholder".to_string(),
+            is_editing: false,
+        }
+    }
+}
+
 #[derive(Default, Debug, Clone, Deserialize, Serialize)]
 pub struct Parent {
-    pub process: String,
-    pub excludes: Vec<String>,
+    pub name: String,
+    pub excludes: Vec<Exclude>,
 
     #[serde(skip)]
     pub is_editing: bool,
 }
+
+impl Parent {
+    pub fn new() -> Self {
+        Self {
+            name: "Parent Placeholder".to_string(),
+            excludes: vec![],
+            is_editing: false,
+        }
+    }
+}
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize)]
+pub struct Exclude {
+    pub name: String,
+    pub is_enabled: bool,
+
+    #[serde(skip)]
+    pub is_editing: bool,
+}
+
+impl Exclude {
+    pub fn new() -> Self {
+        Self {
+            name: "Exclude Placeholder".to_string(),
+            is_enabled: true,
+            is_editing: false,
+        }
+    }
+}

From a4f9a2608c2da5e46ecf534b320fefa1b151296a Mon Sep 17 00:00:00 2001
From: Matthew Wilding <mbwilding@gmail.com>
Date: Sat, 16 Dec 2023 01:48:40 +0800
Subject: [PATCH 08/39] Progress

---
 dygma-layer-switcher-gui/src/structs.rs | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/dygma-layer-switcher-gui/src/structs.rs b/dygma-layer-switcher-gui/src/structs.rs
index da276e8..34f269a 100644
--- a/dygma-layer-switcher-gui/src/structs.rs
+++ b/dygma-layer-switcher-gui/src/structs.rs
@@ -1,5 +1,7 @@
 use serde::{Deserialize, Serialize};
 
+const EDIT_TEXT: &str = "*Click to edit*";
+
 #[derive(Default, Debug, Clone, Deserialize, Serialize)]
 pub struct Layer {
     pub name: String,
@@ -64,7 +66,7 @@ pub struct Window {
 impl Window {
     pub fn new() -> Self {
         Self {
-            name: "Window Placeholder".to_string(),
+            name: EDIT_TEXT.to_string(),
             is_editing: false,
         }
     }
@@ -79,7 +81,7 @@ pub struct Process {
 impl Process {
     pub fn new() -> Self {
         Self {
-            name: "Process Placeholder".to_string(),
+            name: EDIT_TEXT.to_string(),
             is_editing: false,
         }
     }
@@ -97,7 +99,7 @@ pub struct Parent {
 impl Parent {
     pub fn new() -> Self {
         Self {
-            name: "Parent Placeholder".to_string(),
+            name: EDIT_TEXT.to_string(),
             excludes: vec![],
             is_editing: false,
         }
@@ -116,7 +118,7 @@ pub struct Exclude {
 impl Exclude {
     pub fn new() -> Self {
         Self {
-            name: "Exclude Placeholder".to_string(),
+            name: EDIT_TEXT.to_string(),
             is_enabled: true,
             is_editing: false,
         }

From c9ada154f7a763af22ba90ffd7ceb7bb2b636774 Mon Sep 17 00:00:00 2001
From: Matthew Wilding <mbwilding@gmail.com>
Date: Sat, 16 Dec 2023 01:54:41 +0800
Subject: [PATCH 09/39] Progress

---
 dygma-layer-switcher-gui/src/app.rs | 112 +++++++++++++++-------------
 1 file changed, 59 insertions(+), 53 deletions(-)

diff --git a/dygma-layer-switcher-gui/src/app.rs b/dygma-layer-switcher-gui/src/app.rs
index c33f239..4344ef4 100644
--- a/dygma-layer-switcher-gui/src/app.rs
+++ b/dygma-layer-switcher-gui/src/app.rs
@@ -1,6 +1,6 @@
 use crate::structs::*;
 use crate::templates;
-use eframe::egui::{CentralPanel, Context, DragValue, TopBottomPanel};
+use eframe::egui::{CentralPanel, CollapsingHeader, Context, DragValue, TopBottomPanel};
 use eframe::{egui, Frame, Storage};
 use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
@@ -93,65 +93,71 @@ impl DygmaLayerSwitcher {
                         }
                     });
 
-                    ui.collapsing("Windows", |ui| {
-                        layer.apps.iter_mut().for_each(|app| {
-                            if let Mode::Window(window) = &mut app.mode {
-                                ui.horizontal(|ui| {
-                                    ui.checkbox(&mut app.is_enabled, "");
-                                    templates::editable_label(
-                                        ui,
-                                        &mut window.name,
-                                        &mut window.is_editing,
-                                    );
-                                });
-                            }
+                    CollapsingHeader::new("Windows")
+                        .default_open(true)
+                        .show(ui, |ui| {
+                            layer.apps.iter_mut().for_each(|app| {
+                                if let Mode::Window(window) = &mut app.mode {
+                                    ui.horizontal(|ui| {
+                                        ui.checkbox(&mut app.is_enabled, "");
+                                        templates::editable_label(
+                                            ui,
+                                            &mut window.name,
+                                            &mut window.is_editing,
+                                        );
+                                    });
+                                }
+                            });
                         });
-                    });
 
-                    ui.collapsing("Processes", |ui| {
-                        layer.apps.iter_mut().for_each(|app| {
-                            if let Mode::Process(process) = &mut app.mode {
-                                ui.horizontal(|ui| {
-                                    ui.checkbox(&mut app.is_enabled, "");
-                                    templates::editable_label(
-                                        ui,
-                                        &mut process.name,
-                                        &mut process.is_editing,
-                                    );
-                                });
-                            }
+                    CollapsingHeader::new("Processes")
+                        .default_open(true)
+                        .show(ui, |ui| {
+                            layer.apps.iter_mut().for_each(|app| {
+                                if let Mode::Process(process) = &mut app.mode {
+                                    ui.horizontal(|ui| {
+                                        ui.checkbox(&mut app.is_enabled, "");
+                                        templates::editable_label(
+                                            ui,
+                                            &mut process.name,
+                                            &mut process.is_editing,
+                                        );
+                                    });
+                                }
+                            });
                         });
-                    });
 
-                    ui.collapsing("Parents", |ui| {
-                        layer.apps.iter_mut().for_each(|app| {
-                            if let Mode::Parent(parent) = &mut app.mode {
-                                ui.horizontal(|ui| {
-                                    ui.checkbox(&mut app.is_enabled, "");
-                                    if ui.button("Add Exclude").clicked() {
-                                        parent.excludes.push(Exclude::new());
-                                    }
-                                    templates::editable_label(
-                                        ui,
-                                        &mut parent.name,
-                                        &mut parent.is_editing,
-                                    );
-                                });
-                                ui.indent("Excludes", |ui| {
-                                    parent.excludes.iter_mut().for_each(|exclude| {
-                                        ui.horizontal(|ui| {
-                                            ui.checkbox(&mut exclude.is_enabled, "");
-                                            templates::editable_label(
-                                                ui,
-                                                &mut exclude.name,
-                                                &mut exclude.is_editing,
-                                            );
+                    CollapsingHeader::new("Parents")
+                        .default_open(true)
+                        .show(ui, |ui| {
+                            layer.apps.iter_mut().for_each(|app| {
+                                if let Mode::Parent(parent) = &mut app.mode {
+                                    ui.horizontal(|ui| {
+                                        ui.checkbox(&mut app.is_enabled, "");
+                                        if ui.button("Add Exclude").clicked() {
+                                            parent.excludes.push(Exclude::new());
+                                        }
+                                        templates::editable_label(
+                                            ui,
+                                            &mut parent.name,
+                                            &mut parent.is_editing,
+                                        );
+                                    });
+                                    ui.indent("Excludes", |ui| {
+                                        parent.excludes.iter_mut().for_each(|exclude| {
+                                            ui.horizontal(|ui| {
+                                                ui.checkbox(&mut exclude.is_enabled, "");
+                                                templates::editable_label(
+                                                    ui,
+                                                    &mut exclude.name,
+                                                    &mut exclude.is_editing,
+                                                );
+                                            });
                                         });
                                     });
-                                });
-                            }
+                                }
+                            });
                         });
-                    });
                 });
             }
         });

From df521c3d8ad28fab3577e203762463ff0845b302 Mon Sep 17 00:00:00 2001
From: Matthew Wilding <mbwilding@gmail.com>
Date: Sat, 16 Dec 2023 02:20:54 +0800
Subject: [PATCH 10/39] Progress

---
 dygma-layer-switcher-gui/src/app.rs     | 28 +++++++++++++++++++------
 dygma-layer-switcher-gui/src/helpers.rs |  6 ++++++
 dygma-layer-switcher-gui/src/main.rs    |  1 +
 dygma-layer-switcher-gui/src/structs.rs |  2 +-
 4 files changed, 30 insertions(+), 7 deletions(-)
 create mode 100644 dygma-layer-switcher-gui/src/helpers.rs

diff --git a/dygma-layer-switcher-gui/src/app.rs b/dygma-layer-switcher-gui/src/app.rs
index 4344ef4..8165704 100644
--- a/dygma-layer-switcher-gui/src/app.rs
+++ b/dygma-layer-switcher-gui/src/app.rs
@@ -1,3 +1,4 @@
+use crate::helpers::remove_app;
 use crate::structs::*;
 use crate::templates;
 use eframe::egui::{CentralPanel, CollapsingHeader, Context, DragValue, TopBottomPanel};
@@ -17,6 +18,9 @@ pub struct DygmaLayerSwitcher {
 
     #[serde(skip)]
     pub editing_port: bool,
+
+    #[serde(skip)]
+    pub remove_app: Option<usize>,
 }
 
 impl Default for DygmaLayerSwitcher {
@@ -30,6 +34,7 @@ impl Default for DygmaLayerSwitcher {
                 .collect::<BTreeMap<u8, Layer>>(),
 
             editing_port: false,
+            remove_app: None,
         }
     }
 }
@@ -96,7 +101,7 @@ impl DygmaLayerSwitcher {
                     CollapsingHeader::new("Windows")
                         .default_open(true)
                         .show(ui, |ui| {
-                            layer.apps.iter_mut().for_each(|app| {
+                            for (index, app) in layer.apps.iter_mut().enumerate() {
                                 if let Mode::Window(window) = &mut app.mode {
                                     ui.horizontal(|ui| {
                                         ui.checkbox(&mut app.is_enabled, "");
@@ -105,15 +110,18 @@ impl DygmaLayerSwitcher {
                                             &mut window.name,
                                             &mut window.is_editing,
                                         );
+                                        if ui.button("Remove").clicked() {
+                                            self.remove_app = Some(index);
+                                        }
                                     });
                                 }
-                            });
+                            }
                         });
 
                     CollapsingHeader::new("Processes")
                         .default_open(true)
                         .show(ui, |ui| {
-                            layer.apps.iter_mut().for_each(|app| {
+                            for (index, app) in layer.apps.iter_mut().enumerate() {
                                 if let Mode::Process(process) = &mut app.mode {
                                     ui.horizontal(|ui| {
                                         ui.checkbox(&mut app.is_enabled, "");
@@ -122,15 +130,18 @@ impl DygmaLayerSwitcher {
                                             &mut process.name,
                                             &mut process.is_editing,
                                         );
+                                        if ui.button("Remove").clicked() {
+                                            self.remove_app = Some(index);
+                                        }
                                     });
                                 }
-                            });
+                            }
                         });
 
                     CollapsingHeader::new("Parents")
                         .default_open(true)
                         .show(ui, |ui| {
-                            layer.apps.iter_mut().for_each(|app| {
+                            for (index, app) in layer.apps.iter_mut().enumerate() {
                                 if let Mode::Parent(parent) = &mut app.mode {
                                     ui.horizontal(|ui| {
                                         ui.checkbox(&mut app.is_enabled, "");
@@ -142,6 +153,9 @@ impl DygmaLayerSwitcher {
                                             &mut parent.name,
                                             &mut parent.is_editing,
                                         );
+                                        if ui.button("Remove").clicked() {
+                                            self.remove_app = Some(index);
+                                        }
                                     });
                                     ui.indent("Excludes", |ui| {
                                         parent.excludes.iter_mut().for_each(|exclude| {
@@ -156,8 +170,10 @@ impl DygmaLayerSwitcher {
                                         });
                                     });
                                 }
-                            });
+                            }
                         });
+
+                    remove_app(&mut layer.apps, &mut self.remove_app);
                 });
             }
         });
diff --git a/dygma-layer-switcher-gui/src/helpers.rs b/dygma-layer-switcher-gui/src/helpers.rs
new file mode 100644
index 0000000..bd5af47
--- /dev/null
+++ b/dygma-layer-switcher-gui/src/helpers.rs
@@ -0,0 +1,6 @@
+pub fn remove_app<T>(vec: &mut Vec<T>, index: &mut Option<usize>) {
+    if let Some(i) = index {
+        vec.remove(*i);
+        *index = None;
+    }
+}
diff --git a/dygma-layer-switcher-gui/src/main.rs b/dygma-layer-switcher-gui/src/main.rs
index ea0b61a..83fcdb2 100644
--- a/dygma-layer-switcher-gui/src/main.rs
+++ b/dygma-layer-switcher-gui/src/main.rs
@@ -1,6 +1,7 @@
 extern crate core;
 
 mod app;
+mod helpers;
 mod structs;
 mod templates;
 
diff --git a/dygma-layer-switcher-gui/src/structs.rs b/dygma-layer-switcher-gui/src/structs.rs
index 34f269a..e6ac23c 100644
--- a/dygma-layer-switcher-gui/src/structs.rs
+++ b/dygma-layer-switcher-gui/src/structs.rs
@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 
-const EDIT_TEXT: &str = "*Click to edit*";
+const EDIT_TEXT: &str = "Click to edit";
 
 #[derive(Default, Debug, Clone, Deserialize, Serialize)]
 pub struct Layer {

From 567d3aaa25ba8e8b9871edced0664d6c3c192354 Mon Sep 17 00:00:00 2001
From: Matthew Wilding <mbwilding@gmail.com>
Date: Sat, 16 Dec 2023 02:33:13 +0800
Subject: [PATCH 11/39] Progress

---
 dygma-layer-switcher-gui/src/app.rs | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/dygma-layer-switcher-gui/src/app.rs b/dygma-layer-switcher-gui/src/app.rs
index 8165704..b9431c6 100644
--- a/dygma-layer-switcher-gui/src/app.rs
+++ b/dygma-layer-switcher-gui/src/app.rs
@@ -105,14 +105,14 @@ impl DygmaLayerSwitcher {
                                 if let Mode::Window(window) = &mut app.mode {
                                     ui.horizontal(|ui| {
                                         ui.checkbox(&mut app.is_enabled, "");
+                                        if ui.button(" - ").clicked() {
+                                            self.remove_app = Some(index);
+                                        }
                                         templates::editable_label(
                                             ui,
                                             &mut window.name,
                                             &mut window.is_editing,
                                         );
-                                        if ui.button("Remove").clicked() {
-                                            self.remove_app = Some(index);
-                                        }
                                     });
                                 }
                             }
@@ -125,14 +125,14 @@ impl DygmaLayerSwitcher {
                                 if let Mode::Process(process) = &mut app.mode {
                                     ui.horizontal(|ui| {
                                         ui.checkbox(&mut app.is_enabled, "");
+                                        if ui.button(" - ").clicked() {
+                                            self.remove_app = Some(index);
+                                        }
                                         templates::editable_label(
                                             ui,
                                             &mut process.name,
                                             &mut process.is_editing,
                                         );
-                                        if ui.button("Remove").clicked() {
-                                            self.remove_app = Some(index);
-                                        }
                                     });
                                 }
                             }
@@ -145,6 +145,9 @@ impl DygmaLayerSwitcher {
                                 if let Mode::Parent(parent) = &mut app.mode {
                                     ui.horizontal(|ui| {
                                         ui.checkbox(&mut app.is_enabled, "");
+                                        if ui.button(" - ").clicked() {
+                                            self.remove_app = Some(index);
+                                        }
                                         if ui.button("Add Exclude").clicked() {
                                             parent.excludes.push(Exclude::new());
                                         }
@@ -153,9 +156,6 @@ impl DygmaLayerSwitcher {
                                             &mut parent.name,
                                             &mut parent.is_editing,
                                         );
-                                        if ui.button("Remove").clicked() {
-                                            self.remove_app = Some(index);
-                                        }
                                     });
                                     ui.indent("Excludes", |ui| {
                                         parent.excludes.iter_mut().for_each(|exclude| {

From 540162e958093bf456d0a04f19c4e0d0dbb27bee Mon Sep 17 00:00:00 2001
From: Matthew Wilding <mbwilding@gmail.com>
Date: Sat, 16 Dec 2023 02:50:05 +0800
Subject: [PATCH 12/39] Progress

---
 dygma-layer-switcher-gui/src/app.rs     | 43 +++++++++++++++++--------
 dygma-layer-switcher-gui/src/helpers.rs |  2 +-
 2 files changed, 31 insertions(+), 14 deletions(-)

diff --git a/dygma-layer-switcher-gui/src/app.rs b/dygma-layer-switcher-gui/src/app.rs
index b9431c6..3185227 100644
--- a/dygma-layer-switcher-gui/src/app.rs
+++ b/dygma-layer-switcher-gui/src/app.rs
@@ -1,4 +1,4 @@
-use crate::helpers::remove_app;
+use crate::helpers::remove_opt_index;
 use crate::structs::*;
 use crate::templates;
 use eframe::egui::{CentralPanel, CollapsingHeader, Context, DragValue, TopBottomPanel};
@@ -21,6 +21,9 @@ pub struct DygmaLayerSwitcher {
 
     #[serde(skip)]
     pub remove_app: Option<usize>,
+
+    #[serde(skip)]
+    pub remove_exclude: Option<usize>,
 }
 
 impl Default for DygmaLayerSwitcher {
@@ -35,6 +38,7 @@ impl Default for DygmaLayerSwitcher {
 
             editing_port: false,
             remove_app: None,
+            remove_exclude: None,
         }
     }
 }
@@ -157,23 +161,36 @@ impl DygmaLayerSwitcher {
                                             &mut parent.is_editing,
                                         );
                                     });
-                                    ui.indent("Excludes", |ui| {
-                                        parent.excludes.iter_mut().for_each(|exclude| {
-                                            ui.horizontal(|ui| {
-                                                ui.checkbox(&mut exclude.is_enabled, "");
-                                                templates::editable_label(
-                                                    ui,
-                                                    &mut exclude.name,
-                                                    &mut exclude.is_editing,
-                                                );
+
+                                    if !parent.excludes.is_empty() {
+                                        CollapsingHeader::new("Excludes")
+                                            .id_source(format!("excludes_{}", index))
+                                            .default_open(true)
+                                            .show(ui, |ui| {
+                                                parent.excludes.iter_mut().for_each(|exclude| {
+                                                    ui.horizontal(|ui| {
+                                                        ui.checkbox(&mut exclude.is_enabled, "");
+                                                        if ui.button(" - ").clicked() {
+                                                            self.remove_exclude = Some(index);
+                                                        }
+                                                        templates::editable_label(
+                                                            ui,
+                                                            &mut exclude.name,
+                                                            &mut exclude.is_editing,
+                                                        );
+                                                    });
+                                                });
+                                                remove_opt_index(
+                                                    &mut parent.excludes,
+                                                    &mut self.remove_exclude,
+                                                )
                                             });
-                                        });
-                                    });
+                                    }
                                 }
                             }
                         });
 
-                    remove_app(&mut layer.apps, &mut self.remove_app);
+                    remove_opt_index(&mut layer.apps, &mut self.remove_app);
                 });
             }
         });
diff --git a/dygma-layer-switcher-gui/src/helpers.rs b/dygma-layer-switcher-gui/src/helpers.rs
index bd5af47..ec9fc1d 100644
--- a/dygma-layer-switcher-gui/src/helpers.rs
+++ b/dygma-layer-switcher-gui/src/helpers.rs
@@ -1,4 +1,4 @@
-pub fn remove_app<T>(vec: &mut Vec<T>, index: &mut Option<usize>) {
+pub fn remove_opt_index<T>(vec: &mut Vec<T>, index: &mut Option<usize>) {
     if let Some(i) = index {
         vec.remove(*i);
         *index = None;

From c03ffcd7ee4b2120bf1a2b3dba30db4c318af005 Mon Sep 17 00:00:00 2001
From: Matthew Wilding <mbwilding@gmail.com>
Date: Sat, 16 Dec 2023 03:35:38 +0800
Subject: [PATCH 13/39] Progress

---
 dygma-layer-switcher-gui/Cargo.toml  |  8 +++----
 dygma-layer-switcher-gui/src/app.rs  | 17 +++++++-------
 dygma-layer-switcher-gui/src/log.rs  | 32 ++++++++++++++++++++++++++
 dygma-layer-switcher-gui/src/main.rs | 34 ++++++++++++++++++----------
 4 files changed, 67 insertions(+), 24 deletions(-)
 create mode 100644 dygma-layer-switcher-gui/src/log.rs

diff --git a/dygma-layer-switcher-gui/Cargo.toml b/dygma-layer-switcher-gui/Cargo.toml
index 3983745..8e45400 100644
--- a/dygma-layer-switcher-gui/Cargo.toml
+++ b/dygma-layer-switcher-gui/Cargo.toml
@@ -11,7 +11,7 @@ eframe = { version = "0.24", default-features = false, features = [
     "persistence",
 ] }
 serde = { version = "1.0", features = ["derive"] }
-
-#tracing = "0.1"
-#tracing-appender = "0.2"
-#tracing-subscriber = "0.3"
+tracing = "0.1"
+tracing-appender = "0.2"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+log = "0.4.20"
diff --git a/dygma-layer-switcher-gui/src/app.rs b/dygma-layer-switcher-gui/src/app.rs
index 3185227..b263350 100644
--- a/dygma-layer-switcher-gui/src/app.rs
+++ b/dygma-layer-switcher-gui/src/app.rs
@@ -1,6 +1,6 @@
 use crate::helpers::remove_opt_index;
 use crate::structs::*;
-use crate::templates;
+use crate::templates::*;
 use eframe::egui::{CentralPanel, CollapsingHeader, Context, DragValue, TopBottomPanel};
 use eframe::{egui, Frame, Storage};
 use serde::{Deserialize, Serialize};
@@ -57,7 +57,8 @@ impl DygmaLayerSwitcher {
 
     fn logging_control(&mut self, ui: &mut egui::Ui) {
         ui.horizontal(|ui| {
-            ui.label("Logging");
+            ui.label("Logging")
+                .on_hover_text("This setting will enable logging to file.");
             ui.checkbox(&mut self.logging, "");
         });
     }
@@ -65,7 +66,7 @@ impl DygmaLayerSwitcher {
     fn port_control(&mut self, ui: &mut egui::Ui) {
         ui.horizontal(|ui| {
             ui.label("Port");
-            templates::editable_label(ui, &mut self.port, &mut self.editing_port);
+            editable_label(ui, &mut self.port, &mut self.editing_port);
         });
     }
 
@@ -89,7 +90,7 @@ impl DygmaLayerSwitcher {
     fn central_panel(&mut self, ctx: &Context) {
         CentralPanel::default().show(ctx, |ui| {
             for (_index, layer) in self.mappings.iter_mut() {
-                templates::editable_collapsing(ui, &mut layer.name, &mut layer.is_editing, |ui| {
+                editable_collapsing(ui, &mut layer.name, &mut layer.is_editing, |ui| {
                     ui.horizontal(|ui| {
                         if ui.button("Add Window").clicked() {
                             layer.apps.push(App::new_window());
@@ -112,7 +113,7 @@ impl DygmaLayerSwitcher {
                                         if ui.button(" - ").clicked() {
                                             self.remove_app = Some(index);
                                         }
-                                        templates::editable_label(
+                                        editable_label(
                                             ui,
                                             &mut window.name,
                                             &mut window.is_editing,
@@ -132,7 +133,7 @@ impl DygmaLayerSwitcher {
                                         if ui.button(" - ").clicked() {
                                             self.remove_app = Some(index);
                                         }
-                                        templates::editable_label(
+                                        editable_label(
                                             ui,
                                             &mut process.name,
                                             &mut process.is_editing,
@@ -155,7 +156,7 @@ impl DygmaLayerSwitcher {
                                         if ui.button("Add Exclude").clicked() {
                                             parent.excludes.push(Exclude::new());
                                         }
-                                        templates::editable_label(
+                                        editable_label(
                                             ui,
                                             &mut parent.name,
                                             &mut parent.is_editing,
@@ -173,7 +174,7 @@ impl DygmaLayerSwitcher {
                                                         if ui.button(" - ").clicked() {
                                                             self.remove_exclude = Some(index);
                                                         }
-                                                        templates::editable_label(
+                                                        editable_label(
                                                             ui,
                                                             &mut exclude.name,
                                                             &mut exclude.is_editing,
diff --git a/dygma-layer-switcher-gui/src/log.rs b/dygma-layer-switcher-gui/src/log.rs
new file mode 100644
index 0000000..5144041
--- /dev/null
+++ b/dygma-layer-switcher-gui/src/log.rs
@@ -0,0 +1,32 @@
+use tracing_subscriber::filter::{EnvFilter, LevelFilter};
+use tracing_subscriber::fmt;
+use tracing_subscriber::prelude::*;
+
+pub fn init(logging: bool) {
+    let base_filter = EnvFilter::new("info")
+        .add_directive("dygma-layer-switcher-gui=trace".parse().unwrap())
+        .add_directive("egui=warn".parse().unwrap())
+        .add_directive("wgpu=warn".parse().unwrap());
+
+    let console_layer = fmt::layer()
+        .with_ansi(true)
+        .without_time()
+        .compact()
+        .with_filter(base_filter);
+
+    let subscriber_builder = tracing_subscriber::registry();
+
+    if logging {
+        subscriber_builder
+            .with(console_layer)
+            .with(
+                fmt::layer()
+                    .with_ansi(false)
+                    .with_writer(tracing_appender::rolling::daily("logs", "dsl"))
+                    .with_filter(LevelFilter::DEBUG),
+            )
+            .init();
+    } else {
+        subscriber_builder.with(console_layer).init();
+    }
+}
diff --git a/dygma-layer-switcher-gui/src/main.rs b/dygma-layer-switcher-gui/src/main.rs
index 83fcdb2..b7be7e1 100644
--- a/dygma-layer-switcher-gui/src/main.rs
+++ b/dygma-layer-switcher-gui/src/main.rs
@@ -1,25 +1,35 @@
+// hide console window on Windows in release
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+
 extern crate core;
 
 mod app;
 mod helpers;
+mod log;
 mod structs;
 mod templates;
 
 pub fn main() {
+    let options = eframe::NativeOptions {
+        // viewport: Default::default(),
+        vsync: true,
+        follow_system_theme: true,
+        default_theme: eframe::Theme::Dark,
+        // run_and_return: false,
+        // event_loop_builder: None,
+        centered: true,
+        persist_window: true,
+        ..Default::default()
+    };
+
     eframe::run_native(
         "Dygma Layer Switcher",
-        eframe::NativeOptions {
-            // viewport: Default::default(),
-            vsync: true,
-            follow_system_theme: true,
-            default_theme: eframe::Theme::Dark,
-            // run_and_return: false,
-            // event_loop_builder: None,
-            centered: true,
-            persist_window: true,
-            ..Default::default()
-        },
-        Box::new(|cc| Box::new(app::DygmaLayerSwitcher::new(cc))),
+        options,
+        Box::new(|cc| {
+            let app = app::DygmaLayerSwitcher::new(cc);
+            log::init(app.logging);
+            Box::new(app)
+        }),
     )
     .unwrap();
 }

From 68052b208b498373421ec3060bf416421f1d2576 Mon Sep 17 00:00:00 2001
From: Matthew Wilding <mbwilding@gmail.com>
Date: Sat, 16 Dec 2023 11:08:19 +0800
Subject: [PATCH 14/39] UI has most of the features wanted

---
 dygma-layer-switcher-gui/src/app.rs | 251 +++++++++++++++++-----------
 1 file changed, 150 insertions(+), 101 deletions(-)

diff --git a/dygma-layer-switcher-gui/src/app.rs b/dygma-layer-switcher-gui/src/app.rs
index b263350..213242a 100644
--- a/dygma-layer-switcher-gui/src/app.rs
+++ b/dygma-layer-switcher-gui/src/app.rs
@@ -4,7 +4,7 @@ use crate::templates::*;
 use eframe::egui::{CentralPanel, CollapsingHeader, Context, DragValue, TopBottomPanel};
 use eframe::{egui, Frame, Storage};
 use serde::{Deserialize, Serialize};
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, BTreeSet};
 
 const MAX_LAYERS: u8 = 10;
 
@@ -15,6 +15,7 @@ pub struct DygmaLayerSwitcher {
     pub port: String,
     pub base_layer: u8,
     pub mappings: BTreeMap<u8, Layer>,
+    pub hidden_layers: BTreeSet<u8>,
 
     #[serde(skip)]
     pub editing_port: bool,
@@ -24,6 +25,9 @@ pub struct DygmaLayerSwitcher {
 
     #[serde(skip)]
     pub remove_exclude: Option<usize>,
+
+    #[serde(skip)]
+    pub remove_hidden_layer: Option<u8>,
 }
 
 impl Default for DygmaLayerSwitcher {
@@ -35,10 +39,12 @@ impl Default for DygmaLayerSwitcher {
             mappings: (0..MAX_LAYERS)
                 .map(|i| (i, Layer::new(i)))
                 .collect::<BTreeMap<u8, Layer>>(),
+            hidden_layers: BTreeSet::new(),
 
             editing_port: false,
             remove_app: None,
             remove_exclude: None,
+            remove_hidden_layer: None,
         }
     }
 }
@@ -73,125 +79,168 @@ impl DygmaLayerSwitcher {
     fn base_layer_control(&mut self, ui: &mut egui::Ui) {
         ui.horizontal(|ui| {
             ui.label("Base Layer");
-            ui.add(DragValue::new(&mut self.base_layer));
+            ui.add(DragValue::new(&mut self.base_layer).clamp_range(1..=MAX_LAYERS));
+        });
+    }
+
+    fn hidden_layer_control(&mut self, ui: &mut egui::Ui) {
+        ui.horizontal(|ui| {
+            if !self.hidden_layers.is_empty() {
+                CollapsingHeader::new("Hidden Layers")
+                    .default_open(false)
+                    .show(ui, |ui| {
+                        for layer in self.hidden_layers.iter() {
+                            ui.horizontal(|ui| {
+                                if ui.button(" - ").clicked() {
+                                    self.remove_hidden_layer = Some(*layer);
+                                }
+                                ui.label(format!("{}: {}", layer + 1, &self.mappings[layer].name));
+                            });
+                        }
+                        if let Some(layer) = self.remove_hidden_layer {
+                            self.hidden_layers.remove(&layer);
+                            self.remove_hidden_layer = None;
+                        }
+                    });
+                if ui.button("Clear All").clicked() {
+                    self.hidden_layers.clear();
+                }
+            }
         });
     }
 
     fn top_panel(&mut self, ctx: &Context) {
         TopBottomPanel::top("top_panel").show(ctx, |ui| {
-            ui.collapsing("Settings", |ui| {
-                self.logging_control(ui);
-                self.port_control(ui);
-                self.base_layer_control(ui);
-            });
+            CollapsingHeader::new("Settings")
+                .default_open(true)
+                .show(ui, |ui| {
+                    self.logging_control(ui);
+                    self.port_control(ui);
+                    self.base_layer_control(ui);
+                    self.hidden_layer_control(ui);
+                });
         });
     }
 
     fn central_panel(&mut self, ctx: &Context) {
         CentralPanel::default().show(ctx, |ui| {
-            for (_index, layer) in self.mappings.iter_mut() {
-                editable_collapsing(ui, &mut layer.name, &mut layer.is_editing, |ui| {
-                    ui.horizontal(|ui| {
-                        if ui.button("Add Window").clicked() {
-                            layer.apps.push(App::new_window());
-                        }
-                        if ui.button("Add Process").clicked() {
-                            layer.apps.push(App::new_process());
-                        }
-                        if ui.button("Add Parent").clicked() {
-                            layer.apps.push(App::new_parent());
-                        }
-                    });
-
-                    CollapsingHeader::new("Windows")
-                        .default_open(true)
-                        .show(ui, |ui| {
-                            for (index, app) in layer.apps.iter_mut().enumerate() {
-                                if let Mode::Window(window) = &mut app.mode {
-                                    ui.horizontal(|ui| {
-                                        ui.checkbox(&mut app.is_enabled, "");
-                                        if ui.button(" - ").clicked() {
-                                            self.remove_app = Some(index);
-                                        }
-                                        editable_label(
-                                            ui,
-                                            &mut window.name,
-                                            &mut window.is_editing,
-                                        );
-                                    });
-                                }
+            for (index, layer) in self.mappings.iter_mut() {
+                if self.hidden_layers.contains(index) {
+                    continue;
+                }
+                ui.horizontal(|ui| {
+                    if ui.button("👁").clicked() {
+                        self.hidden_layers.insert(*index);
+                    }
+                    editable_collapsing(ui, &mut layer.name, &mut layer.is_editing, |ui| {
+                        ui.horizontal(|ui| {
+                            if ui.button("Add Window").clicked() {
+                                layer.apps.push(App::new_window());
+                            }
+                            if ui.button("Add Process").clicked() {
+                                layer.apps.push(App::new_process());
+                            }
+                            if ui.button("Add Parent").clicked() {
+                                layer.apps.push(App::new_parent());
                             }
                         });
 
-                    CollapsingHeader::new("Processes")
-                        .default_open(true)
-                        .show(ui, |ui| {
-                            for (index, app) in layer.apps.iter_mut().enumerate() {
-                                if let Mode::Process(process) = &mut app.mode {
-                                    ui.horizontal(|ui| {
-                                        ui.checkbox(&mut app.is_enabled, "");
-                                        if ui.button(" - ").clicked() {
-                                            self.remove_app = Some(index);
-                                        }
-                                        editable_label(
-                                            ui,
-                                            &mut process.name,
-                                            &mut process.is_editing,
-                                        );
-                                    });
+                        CollapsingHeader::new("Windows")
+                            .default_open(true)
+                            .show(ui, |ui| {
+                                for (index, app) in layer.apps.iter_mut().enumerate() {
+                                    if let Mode::Window(window) = &mut app.mode {
+                                        ui.horizontal(|ui| {
+                                            ui.checkbox(&mut app.is_enabled, "");
+                                            if ui.button(" - ").clicked() {
+                                                self.remove_app = Some(index);
+                                            }
+                                            editable_label(
+                                                ui,
+                                                &mut window.name,
+                                                &mut window.is_editing,
+                                            );
+                                        });
+                                    }
                                 }
-                            }
-                        });
+                            });
 
-                    CollapsingHeader::new("Parents")
-                        .default_open(true)
-                        .show(ui, |ui| {
-                            for (index, app) in layer.apps.iter_mut().enumerate() {
-                                if let Mode::Parent(parent) = &mut app.mode {
-                                    ui.horizontal(|ui| {
-                                        ui.checkbox(&mut app.is_enabled, "");
-                                        if ui.button(" - ").clicked() {
-                                            self.remove_app = Some(index);
-                                        }
-                                        if ui.button("Add Exclude").clicked() {
-                                            parent.excludes.push(Exclude::new());
-                                        }
-                                        editable_label(
-                                            ui,
-                                            &mut parent.name,
-                                            &mut parent.is_editing,
-                                        );
-                                    });
-
-                                    if !parent.excludes.is_empty() {
-                                        CollapsingHeader::new("Excludes")
-                                            .id_source(format!("excludes_{}", index))
-                                            .default_open(true)
-                                            .show(ui, |ui| {
-                                                parent.excludes.iter_mut().for_each(|exclude| {
-                                                    ui.horizontal(|ui| {
-                                                        ui.checkbox(&mut exclude.is_enabled, "");
-                                                        if ui.button(" - ").clicked() {
-                                                            self.remove_exclude = Some(index);
-                                                        }
-                                                        editable_label(
-                                                            ui,
-                                                            &mut exclude.name,
-                                                            &mut exclude.is_editing,
-                                                        );
-                                                    });
+                        CollapsingHeader::new("Processes")
+                            .default_open(true)
+                            .show(ui, |ui| {
+                                for (index, app) in layer.apps.iter_mut().enumerate() {
+                                    if let Mode::Process(process) = &mut app.mode {
+                                        ui.horizontal(|ui| {
+                                            ui.checkbox(&mut app.is_enabled, "");
+                                            if ui.button(" - ").clicked() {
+                                                self.remove_app = Some(index);
+                                            }
+                                            editable_label(
+                                                ui,
+                                                &mut process.name,
+                                                &mut process.is_editing,
+                                            );
+                                        });
+                                    }
+                                }
+                            });
+
+                        CollapsingHeader::new("Parents")
+                            .default_open(true)
+                            .show(ui, |ui| {
+                                for (index, app) in layer.apps.iter_mut().enumerate() {
+                                    if let Mode::Parent(parent) = &mut app.mode {
+                                        ui.horizontal(|ui| {
+                                            ui.checkbox(&mut app.is_enabled, "");
+                                            if ui.button(" - ").clicked() {
+                                                self.remove_app = Some(index);
+                                            }
+                                            if ui.button("Add Exclude").clicked() {
+                                                parent.excludes.push(Exclude::new());
+                                            }
+                                            editable_label(
+                                                ui,
+                                                &mut parent.name,
+                                                &mut parent.is_editing,
+                                            );
+                                        });
+
+                                        if !parent.excludes.is_empty() {
+                                            CollapsingHeader::new("Excludes")
+                                                .id_source(format!("excludes_{}", index))
+                                                .default_open(true)
+                                                .show(ui, |ui| {
+                                                    parent.excludes.iter_mut().for_each(
+                                                        |exclude| {
+                                                            ui.horizontal(|ui| {
+                                                                ui.checkbox(
+                                                                    &mut exclude.is_enabled,
+                                                                    "",
+                                                                );
+                                                                if ui.button(" - ").clicked() {
+                                                                    self.remove_exclude =
+                                                                        Some(index);
+                                                                }
+                                                                editable_label(
+                                                                    ui,
+                                                                    &mut exclude.name,
+                                                                    &mut exclude.is_editing,
+                                                                );
+                                                            });
+                                                        },
+                                                    );
+                                                    remove_opt_index(
+                                                        &mut parent.excludes,
+                                                        &mut self.remove_exclude,
+                                                    )
                                                 });
-                                                remove_opt_index(
-                                                    &mut parent.excludes,
-                                                    &mut self.remove_exclude,
-                                                )
-                                            });
+                                        }
                                     }
                                 }
-                            }
-                        });
+                            });
 
-                    remove_opt_index(&mut layer.apps, &mut self.remove_app);
+                        remove_opt_index(&mut layer.apps, &mut self.remove_app);
+                    });
                 });
             }
         });

From 7bec61cde58cb1b9df8940007b2f782e50279fc8 Mon Sep 17 00:00:00 2001
From: Matthew Wilding <mbwilding@gmail.com>
Date: Sat, 16 Dec 2023 11:59:50 +0800
Subject: [PATCH 15/39] Updated ui

---
 dygma-layer-switcher-gui/Cargo.toml       |  3 +
 dygma-layer-switcher-gui/src/app.rs       | 72 +++++++++++++++++++----
 dygma-layer-switcher-gui/src/main.rs      | 19 +++---
 dygma-layer-switcher-gui/src/single.rs    | 14 +++++
 dygma-layer-switcher-gui/src/templates.rs | 10 +++-
 5 files changed, 96 insertions(+), 22 deletions(-)
 create mode 100644 dygma-layer-switcher-gui/src/single.rs

diff --git a/dygma-layer-switcher-gui/Cargo.toml b/dygma-layer-switcher-gui/Cargo.toml
index 8e45400..f876848 100644
--- a/dygma-layer-switcher-gui/Cargo.toml
+++ b/dygma-layer-switcher-gui/Cargo.toml
@@ -5,12 +5,15 @@ edition = "2021"
 authors = ["Matthew Wilding <mbwilding@gmail.com>"]
 
 [dependencies]
+anyhow = "1.0"
+dygma_focus = { git = "https://github.com/mbwilding/dygma-focus-api-rs" }
 eframe = { version = "0.24", default-features = false, features = [
     "default_fonts",
     "wgpu",
     "persistence",
 ] }
 serde = { version = "1.0", features = ["derive"] }
+single-instance = "0.3"
 tracing = "0.1"
 tracing-appender = "0.2"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
diff --git a/dygma-layer-switcher-gui/src/app.rs b/dygma-layer-switcher-gui/src/app.rs
index 213242a..cbe5e70 100644
--- a/dygma-layer-switcher-gui/src/app.rs
+++ b/dygma-layer-switcher-gui/src/app.rs
@@ -1,10 +1,13 @@
 use crate::helpers::remove_opt_index;
 use crate::structs::*;
 use crate::templates::*;
+use dygma_focus::Focus;
 use eframe::egui::{CentralPanel, CollapsingHeader, Context, DragValue, TopBottomPanel};
 use eframe::{egui, Frame, Storage};
+use log::warn;
 use serde::{Deserialize, Serialize};
 use std::collections::{BTreeMap, BTreeSet};
+use tracing::error;
 
 const MAX_LAYERS: u8 = 10;
 
@@ -32,9 +35,18 @@ pub struct DygmaLayerSwitcher {
 
 impl Default for DygmaLayerSwitcher {
     fn default() -> Self {
+        let focus = Focus::default();
+        let port = focus.find_first().unwrap_or_else(|e| {
+            error!(
+                "Connect a Dygma keyboard and restart the application: {:?}",
+                e
+            );
+            std::process::exit(1);
+        });
+
         Self {
             logging: false,
-            port: String::new(),
+            port: port.port,
             base_layer: 1,
             mappings: (0..MAX_LAYERS)
                 .map(|i| (i, Layer::new(i)))
@@ -64,22 +76,36 @@ impl DygmaLayerSwitcher {
     fn logging_control(&mut self, ui: &mut egui::Ui) {
         ui.horizontal(|ui| {
             ui.label("Logging")
-                .on_hover_text("This setting will enable logging to file.");
+                .on_hover_text("Enables logging to file.");
             ui.checkbox(&mut self.logging, "");
         });
     }
 
     fn port_control(&mut self, ui: &mut egui::Ui) {
         ui.horizontal(|ui| {
-            ui.label("Port");
+            ui.label("Port")
+                .on_hover_text("The serial port to communicate with.");
+            if ui
+                .button("↻")
+                .on_hover_text("Rescan for the communication port.")
+                .clicked()
+            {
+                let focus = Focus::default();
+                match focus.find_first() {
+                    Ok(port) => self.port = port.port,
+                    Err(e) => warn!("No Dygma keyboard detected: {:?}", e),
+                }
+            };
             editable_label(ui, &mut self.port, &mut self.editing_port);
         });
     }
 
     fn base_layer_control(&mut self, ui: &mut egui::Ui) {
         ui.horizontal(|ui| {
-            ui.label("Base Layer");
-            ui.add(DragValue::new(&mut self.base_layer).clamp_range(1..=MAX_LAYERS));
+            ui.label("Base Layer")
+                .on_hover_text("The layer to return to.");
+            ui.add(DragValue::new(&mut self.base_layer).clamp_range(1..=MAX_LAYERS))
+                .on_hover_text("Click and drag to change the base layer.");
         });
     }
 
@@ -91,7 +117,11 @@ impl DygmaLayerSwitcher {
                     .show(ui, |ui| {
                         for layer in self.hidden_layers.iter() {
                             ui.horizontal(|ui| {
-                                if ui.button(" - ").clicked() {
+                                if ui
+                                    .button(" - ")
+                                    .on_hover_text(format!("Unhide layer {}.", layer + 1))
+                                    .clicked()
+                                {
                                     self.remove_hidden_layer = Some(*layer);
                                 }
                                 ui.label(format!("{}: {}", layer + 1, &self.mappings[layer].name));
@@ -102,9 +132,6 @@ impl DygmaLayerSwitcher {
                             self.remove_hidden_layer = None;
                         }
                     });
-                if ui.button("Clear All").clicked() {
-                    self.hidden_layers.clear();
-                }
             }
         });
     }
@@ -124,6 +151,7 @@ impl DygmaLayerSwitcher {
 
     fn central_panel(&mut self, ctx: &Context) {
         CentralPanel::default().show(ctx, |ui| {
+            ui.label("Right click to rename the layer.");
             for (index, layer) in self.mappings.iter_mut() {
                 if self.hidden_layers.contains(index) {
                     continue;
@@ -152,7 +180,11 @@ impl DygmaLayerSwitcher {
                                     if let Mode::Window(window) = &mut app.mode {
                                         ui.horizontal(|ui| {
                                             ui.checkbox(&mut app.is_enabled, "");
-                                            if ui.button(" - ").clicked() {
+                                            if ui
+                                                .button(" - ")
+                                                .on_hover_text("Remove this window.")
+                                                .clicked()
+                                            {
                                                 self.remove_app = Some(index);
                                             }
                                             editable_label(
@@ -172,7 +204,11 @@ impl DygmaLayerSwitcher {
                                     if let Mode::Process(process) = &mut app.mode {
                                         ui.horizontal(|ui| {
                                             ui.checkbox(&mut app.is_enabled, "");
-                                            if ui.button(" - ").clicked() {
+                                            if ui
+                                                .button(" - ")
+                                                .on_hover_text("Remove this process.")
+                                                .clicked()
+                                            {
                                                 self.remove_app = Some(index);
                                             }
                                             editable_label(
@@ -192,7 +228,11 @@ impl DygmaLayerSwitcher {
                                     if let Mode::Parent(parent) = &mut app.mode {
                                         ui.horizontal(|ui| {
                                             ui.checkbox(&mut app.is_enabled, "");
-                                            if ui.button(" - ").clicked() {
+                                            if ui
+                                                .button(" - ")
+                                                .on_hover_text("Remove this parent.")
+                                                .clicked()
+                                            {
                                                 self.remove_app = Some(index);
                                             }
                                             if ui.button("Add Exclude").clicked() {
@@ -217,7 +257,13 @@ impl DygmaLayerSwitcher {
                                                                     &mut exclude.is_enabled,
                                                                     "",
                                                                 );
-                                                                if ui.button(" - ").clicked() {
+                                                                if ui
+                                                                    .button(" - ")
+                                                                    .on_hover_text(
+                                                                        "Remove this exclude.",
+                                                                    )
+                                                                    .clicked()
+                                                                {
                                                                     self.remove_exclude =
                                                                         Some(index);
                                                                 }
diff --git a/dygma-layer-switcher-gui/src/main.rs b/dygma-layer-switcher-gui/src/main.rs
index b7be7e1..240062c 100644
--- a/dygma-layer-switcher-gui/src/main.rs
+++ b/dygma-layer-switcher-gui/src/main.rs
@@ -1,20 +1,24 @@
 // hide console window on Windows in release
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 
-extern crate core;
+use anyhow::Result;
+use eframe::*;
 
 mod app;
 mod helpers;
 mod log;
+mod single;
 mod structs;
 mod templates;
 
-pub fn main() {
-    let options = eframe::NativeOptions {
+pub fn main() -> Result<()> {
+    single::check()?;
+
+    let options = NativeOptions {
         // viewport: Default::default(),
         vsync: true,
         follow_system_theme: true,
-        default_theme: eframe::Theme::Dark,
+        default_theme: Theme::Dark,
         // run_and_return: false,
         // event_loop_builder: None,
         centered: true,
@@ -22,7 +26,7 @@ pub fn main() {
         ..Default::default()
     };
 
-    eframe::run_native(
+    run_native(
         "Dygma Layer Switcher",
         options,
         Box::new(|cc| {
@@ -30,6 +34,7 @@ pub fn main() {
             log::init(app.logging);
             Box::new(app)
         }),
-    )
-    .unwrap();
+    )?;
+
+    Ok(())
 }
diff --git a/dygma-layer-switcher-gui/src/single.rs b/dygma-layer-switcher-gui/src/single.rs
new file mode 100644
index 0000000..fad0b3a
--- /dev/null
+++ b/dygma-layer-switcher-gui/src/single.rs
@@ -0,0 +1,14 @@
+use anyhow::Result;
+use single_instance::SingleInstance;
+use tracing::error;
+
+pub fn check() -> Result<()> {
+    let instance = SingleInstance::new("dygma-layer-switcher")?;
+
+    if !instance.is_single() {
+        error!("Another instance of Dygma Layer Switcher is already running");
+        std::process::exit(1);
+    }
+
+    Ok(())
+}
diff --git a/dygma-layer-switcher-gui/src/templates.rs b/dygma-layer-switcher-gui/src/templates.rs
index 682a675..d6e2d9b 100644
--- a/dygma-layer-switcher-gui/src/templates.rs
+++ b/dygma-layer-switcher-gui/src/templates.rs
@@ -2,7 +2,10 @@ use eframe::egui;
 
 pub fn editable_label(ui: &mut egui::Ui, value: &mut String, editing: &mut bool) {
     if *editing {
-        if ui.text_edit_singleline(value).lost_focus() {
+        if ui
+            .text_edit_singleline(value)
+            .lost_focus()
+        {
             *editing = false;
         }
     } else if ui.button(value.as_str()).clicked() {
@@ -17,7 +20,10 @@ pub fn editable_collapsing<F: FnMut(&mut egui::Ui)>(
     mut content: F,
 ) {
     if *editing {
-        if ui.text_edit_singleline(value).lost_focus() {
+        if ui
+            .text_edit_singleline(value)
+            .lost_focus()
+        {
             *editing = false;
         }
     } else {

From e66d889e0b89659d541323b0c950dd4358e7ec7f Mon Sep 17 00:00:00 2001
From: Matthew Wilding <mbwilding@gmail.com>
Date: Sat, 16 Dec 2023 12:36:45 +0800
Subject: [PATCH 16/39] Refactor

---
 Cargo.toml                                    |   3 -
 common/Cargo.toml                             |  15 -
 common/src/app.rs                             |  25 --
 common/src/config.rs                          | 262 ------------------
 common/src/layer.rs                           |  33 ---
 common/src/lib.rs                             |   4 -
 dygma-layer-switcher-gui/Cargo.toml           |  20 --
 dygma-layer-switcher-gui/src/log.rs           |  32 ---
 dygma-layer-switcher-gui/src/main.rs          |  40 ---
 dygma-layer-switcher-gui/src/single.rs        |  14 -
 dygma-layer-switcher/Cargo.toml               |  27 +-
 .../src/app.rs                                |   3 +-
 .../src/helpers.rs                            |   0
 dygma-layer-switcher/src/layer.rs             |  34 +++
 dygma-layer-switcher/src/log.rs               |  48 ++--
 dygma-layer-switcher/src/main.rs              |  55 ++--
 .../src/single.rs                             |   0
 .../src/structs.rs                            |   6 +
 .../src/templates.rs                          |   0
 {windows => dygma-layer-switcher}/src/tray.rs |   0
 dygma-layer-switcher/src/windows.rs           | 155 +++++++++++
 windows/Cargo.toml                            |  21 --
 windows/src/collection.rs                     |  91 ------
 windows/src/init.rs                           |  46 ---
 windows/src/lib.rs                            |  11 -
 windows/src/message_loop.rs                   |  33 ---
 26 files changed, 276 insertions(+), 702 deletions(-)
 delete mode 100644 common/Cargo.toml
 delete mode 100644 common/src/app.rs
 delete mode 100644 common/src/config.rs
 delete mode 100644 common/src/layer.rs
 delete mode 100644 common/src/lib.rs
 delete mode 100644 dygma-layer-switcher-gui/Cargo.toml
 delete mode 100644 dygma-layer-switcher-gui/src/log.rs
 delete mode 100644 dygma-layer-switcher-gui/src/main.rs
 delete mode 100644 dygma-layer-switcher-gui/src/single.rs
 rename {dygma-layer-switcher-gui => dygma-layer-switcher}/src/app.rs (99%)
 rename {dygma-layer-switcher-gui => dygma-layer-switcher}/src/helpers.rs (100%)
 create mode 100644 dygma-layer-switcher/src/layer.rs
 rename {common => dygma-layer-switcher}/src/single.rs (100%)
 rename {dygma-layer-switcher-gui => dygma-layer-switcher}/src/structs.rs (94%)
 rename {dygma-layer-switcher-gui => dygma-layer-switcher}/src/templates.rs (100%)
 rename {windows => dygma-layer-switcher}/src/tray.rs (100%)
 create mode 100644 dygma-layer-switcher/src/windows.rs
 delete mode 100644 windows/Cargo.toml
 delete mode 100644 windows/src/collection.rs
 delete mode 100644 windows/src/init.rs
 delete mode 100644 windows/src/lib.rs
 delete mode 100644 windows/src/message_loop.rs

diff --git a/Cargo.toml b/Cargo.toml
index cd0925c..b838745 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -2,9 +2,6 @@
 resolver = "2"
 members = [
     "dygma-layer-switcher",
-    "dygma-layer-switcher-gui",
-    "common",
-    "windows",
 ]
 
 [profile.release]
diff --git a/common/Cargo.toml b/common/Cargo.toml
deleted file mode 100644
index c77acd8..0000000
--- a/common/Cargo.toml
+++ /dev/null
@@ -1,15 +0,0 @@
-[package]
-name = "common"
-version = "0.1.0"
-edition = "2021"
-authors = ["Matthew Wilding <mbwilding@gmail.com>"]
-
-[dependencies]
-dygma_focus = { git = "https://github.com/mbwilding/dygma-focus-api-rs" }
-anyhow = "1.0"
-log = "0.4"
-single-instance = "0.3"
-serde = { version = "1.0", features = ["derive"] }
-serde_yaml = "0.9"
-sysinfo = "0.29"
-tracing = "0.1"
diff --git a/common/src/app.rs b/common/src/app.rs
deleted file mode 100644
index e58309a..0000000
--- a/common/src/app.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Default, Debug, Clone, Deserialize, Serialize)]
-pub struct Layer {
-    pub layer: u8,
-    pub apps: Vec<App>,
-}
-
-#[derive(Default, Debug, Clone, Deserialize, Serialize)]
-pub struct App {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub window: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub process: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub parent: Option<Parent>,
-}
-
-#[derive(Default, Debug, Clone, Deserialize, Serialize)]
-pub struct Parent {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub process: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub excludes: Option<Vec<String>>,
-}
diff --git a/common/src/config.rs b/common/src/config.rs
deleted file mode 100644
index 28cc0f0..0000000
--- a/common/src/config.rs
+++ /dev/null
@@ -1,262 +0,0 @@
-use crate::app::{App, Layer, Parent};
-use serde::{Deserialize, Serialize};
-use std::fs::File;
-use std::io;
-use std::io::{Read, Write};
-use sysinfo::{Process, ProcessExt, System, SystemExt};
-use tracing::{error, trace, warn};
-
-const CONFIG_PATH: &str = "config.yml";
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct Config {
-    pub logging: Option<bool>,
-    pub comm_port: Option<String>,
-    pub base_layer: Option<u8>,
-    pub mappings: Option<Vec<Layer>>,
-}
-
-#[derive(Debug, Default, Clone, Deserialize, Serialize)]
-pub struct AppDetails {
-    pub window: Option<String>,
-    pub process: Option<String>,
-}
-
-impl Default for Config {
-    fn default() -> Self {
-        let focus = dygma_focus::Focus::default();
-
-        let device = focus.find_first().unwrap_or_else(|e| {
-            error!(
-                "Connect a Dygma keyboard and restart the application: {:?}",
-                e
-            );
-            std::process::exit(1);
-        });
-
-        Config {
-            logging: Some(false),
-            comm_port: Some(device.port),
-            base_layer: Some(1),
-            mappings: Some(vec![]),
-        }
-    }
-}
-
-impl Config {
-    pub fn load() -> Config {
-        let file = File::open(CONFIG_PATH);
-        let config = match file {
-            Ok(mut f) => {
-                let mut contents = String::new();
-                match f.read_to_string(&mut contents) {
-                    Ok(_) => match serde_yaml::from_str(&contents) {
-                        Ok(data) => {
-                            trace!("Config loaded");
-                            data
-                        }
-                        Err(e) => {
-                            error!("Error parsing config file: {:?}", e);
-                            Config::default()
-                        }
-                    },
-                    Err(e) => {
-                        error!("Error reading config file: {:?}", e);
-                        Config::default()
-                    }
-                }
-            }
-            Err(_) => {
-                warn!("No config file found, creating with default config");
-                let default_config = Config::default();
-                match File::create(CONFIG_PATH) {
-                    Ok(mut file) => match serde_yaml::to_string(&default_config) {
-                        Ok(yaml) => {
-                            if let Err(e) = file.write_all(yaml.as_bytes()) {
-                                error!("Failed to write default config to file: {:?}", e);
-                            }
-                        }
-                        Err(e) => {
-                            error!("Failed to serialize default config: {:?}", e);
-                        }
-                    },
-                    Err(e) => {
-                        error!("Failed to create config file: {:?}", e);
-                    }
-                }
-
-                default_config
-            }
-        };
-
-        config
-    }
-
-    pub fn add(&mut self) {
-        if let Some(mappings) = self.mappings.as_mut() {
-            mappings.push(Layer::default());
-        } else {
-            error!("Mappings not initialized");
-        }
-    }
-
-    pub fn remove(&mut self, index: usize) {
-        if let Some(mappings) = self.mappings.as_mut() {
-            if index < mappings.len() {
-                mappings.remove(index);
-            }
-        } else {
-            error!("Mappings not initialized");
-        }
-    }
-
-    pub fn save(&self) {
-        match File::create(CONFIG_PATH) {
-            Ok(file) => {
-                let mut writer = io::BufWriter::new(file);
-                if let Err(e) = serde_yaml::to_writer(&mut writer, &self) {
-                    error!("Failed to serialize config: {:?}", e);
-                }
-                if let Err(e) = writer.flush() {
-                    error!("Failed to write config to file: {:?}", e);
-                }
-            }
-            Err(e) => {
-                error!("Failed to create config file: {:?}", e);
-            }
-        }
-    }
-
-    pub fn check_process(&self, app_details: &AppDetails) -> Option<u8> {
-        app_details
-            .process
-            .as_ref()
-            .and_then(|x| self.match_property_opt_string(x, |mapping| &mapping.process))
-    }
-
-    pub fn check_window(&self, app_details: &AppDetails) -> Option<u8> {
-        app_details
-            .window
-            .as_ref()
-            .and_then(|x| self.match_property_opt_string(x, |mapping| &mapping.window))
-    }
-
-    pub fn check_parent(&self, app_details: &AppDetails) -> Option<u8> {
-        if let Some(process) = &app_details.process {
-            let mut sys = System::new();
-            sys.refresh_processes();
-
-            if let Some((_, proc)) = sys
-                .processes()
-                .iter()
-                .find(|(_, proc)| proc.name().to_lowercase().contains(&process.to_lowercase()))
-            {
-                return self.check_parent_recursively(proc, &sys, |mapping| &mapping.parent, 0);
-            }
-        }
-
-        None
-    }
-
-    fn is_process_excluded(&self, process: &str, parent_process: &str) -> bool {
-        if let Some(layers) = &self.mappings {
-            layers.iter().any(|layer| {
-                layer.apps.iter().any(|app| {
-                    if let Some(parent) = &app.parent {
-                        if let Some(parent_process_name) = &parent.process {
-                            if parent_process_name
-                                .to_lowercase()
-                                .contains(&parent_process.to_lowercase())
-                            {
-                                if let Some(excludes) = &parent.excludes {
-                                    return excludes.iter().any(|excluded_process| {
-                                        excluded_process
-                                            .to_lowercase()
-                                            .contains(&process.to_lowercase())
-                                    });
-                                }
-                            }
-                        }
-                    }
-                    false
-                })
-            })
-        } else {
-            false
-        }
-    }
-
-    fn check_parent_recursively<F>(
-        &self,
-        proc: &Process,
-        sys: &System,
-        mapping_property: F,
-        level: usize,
-    ) -> Option<u8>
-    where
-        F: Fn(&App) -> &Option<Parent> + Copy,
-    {
-        if let Some(parent_pid) = proc.parent() {
-            if let Some(parent_proc) = sys.processes().get(&parent_pid) {
-                if level > 0 && self.is_process_excluded(proc.name(), parent_proc.name()) {
-                    return None;
-                }
-
-                trace!("Parent: {:?}, Level: {}", parent_proc.name(), level);
-
-                if let Some(layer) =
-                    self.match_property_opt_parent(parent_proc.name(), mapping_property)
-                {
-                    return Some(layer);
-                }
-
-                return self.check_parent_recursively(
-                    parent_proc,
-                    sys,
-                    mapping_property,
-                    level + 1,
-                );
-            }
-        }
-
-        None
-    }
-
-    fn match_property_opt_parent<T, F>(&self, app_property: T, mapping_property: F) -> Option<u8>
-    where
-        T: AsRef<str>,
-        F: Fn(&App) -> &Option<Parent>,
-    {
-        let app_prop = app_property.as_ref().to_lowercase();
-
-        self.mappings.as_ref()?.iter().find_map(|mapping| {
-            mapping.apps.iter().find_map(|app| {
-                mapping_property(app)
-                    .as_ref()?
-                    .process
-                    .as_ref()?
-                    .to_lowercase()
-                    .contains(&app_prop)
-                    .then_some(mapping.layer)
-            })
-        })
-    }
-
-    fn match_property_opt_string<T, F>(&self, app_property: T, mapping_property: F) -> Option<u8>
-    where
-        T: AsRef<str>,
-        F: Fn(&App) -> &Option<String>,
-    {
-        let app_prop = app_property.as_ref().to_lowercase();
-
-        self.mappings.as_ref()?.iter().find_map(|mapping| {
-            mapping.apps.iter().find_map(|app| {
-                mapping_property(app)
-                    .as_ref()?
-                    .to_lowercase()
-                    .contains(&app_prop)
-                    .then_some(mapping.layer)
-            })
-        })
-    }
-}
diff --git a/common/src/layer.rs b/common/src/layer.rs
deleted file mode 100644
index 3e67565..0000000
--- a/common/src/layer.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-use crate::config::{AppDetails, Config};
-use tracing::{debug, error, info};
-
-pub fn process(app_details: &AppDetails) {
-    debug!("{:?}", app_details);
-
-    let config = Config::load();
-
-    let layer = config
-        .check_window(app_details)
-        .or_else(|| config.check_process(app_details))
-        .or_else(|| config.check_parent(app_details))
-        .unwrap_or_else(|| config.base_layer.unwrap_or_default());
-
-    layer_change(&config, layer);
-}
-
-fn layer_change(config: &Config, layer: u8) {
-    if let Some(port) = &config.comm_port {
-        let mut focus = dygma_focus::Focus::default();
-        if focus.open_via_port(port).is_ok() {
-            if focus.layer_move_to(layer - 1).is_ok() {
-                info!("Changed layer: {}", layer);
-            } else {
-                error!("Failed to write to serial port: {:?}", &config.comm_port);
-            }
-        } else {
-            error!("Failed to open serial port: {:?}", &config.comm_port);
-        }
-    } else {
-        error!("No serial port specified");
-    }
-}
diff --git a/common/src/lib.rs b/common/src/lib.rs
deleted file mode 100644
index 1bdd65b..0000000
--- a/common/src/lib.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-pub mod app;
-pub mod config;
-pub mod layer;
-pub mod single;
diff --git a/dygma-layer-switcher-gui/Cargo.toml b/dygma-layer-switcher-gui/Cargo.toml
deleted file mode 100644
index f876848..0000000
--- a/dygma-layer-switcher-gui/Cargo.toml
+++ /dev/null
@@ -1,20 +0,0 @@
-[package]
-name = "dygma-layer-switcher-gui"
-version = "0.1.0"
-edition = "2021"
-authors = ["Matthew Wilding <mbwilding@gmail.com>"]
-
-[dependencies]
-anyhow = "1.0"
-dygma_focus = { git = "https://github.com/mbwilding/dygma-focus-api-rs" }
-eframe = { version = "0.24", default-features = false, features = [
-    "default_fonts",
-    "wgpu",
-    "persistence",
-] }
-serde = { version = "1.0", features = ["derive"] }
-single-instance = "0.3"
-tracing = "0.1"
-tracing-appender = "0.2"
-tracing-subscriber = { version = "0.3", features = ["env-filter"] }
-log = "0.4.20"
diff --git a/dygma-layer-switcher-gui/src/log.rs b/dygma-layer-switcher-gui/src/log.rs
deleted file mode 100644
index 5144041..0000000
--- a/dygma-layer-switcher-gui/src/log.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-use tracing_subscriber::filter::{EnvFilter, LevelFilter};
-use tracing_subscriber::fmt;
-use tracing_subscriber::prelude::*;
-
-pub fn init(logging: bool) {
-    let base_filter = EnvFilter::new("info")
-        .add_directive("dygma-layer-switcher-gui=trace".parse().unwrap())
-        .add_directive("egui=warn".parse().unwrap())
-        .add_directive("wgpu=warn".parse().unwrap());
-
-    let console_layer = fmt::layer()
-        .with_ansi(true)
-        .without_time()
-        .compact()
-        .with_filter(base_filter);
-
-    let subscriber_builder = tracing_subscriber::registry();
-
-    if logging {
-        subscriber_builder
-            .with(console_layer)
-            .with(
-                fmt::layer()
-                    .with_ansi(false)
-                    .with_writer(tracing_appender::rolling::daily("logs", "dsl"))
-                    .with_filter(LevelFilter::DEBUG),
-            )
-            .init();
-    } else {
-        subscriber_builder.with(console_layer).init();
-    }
-}
diff --git a/dygma-layer-switcher-gui/src/main.rs b/dygma-layer-switcher-gui/src/main.rs
deleted file mode 100644
index 240062c..0000000
--- a/dygma-layer-switcher-gui/src/main.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-// hide console window on Windows in release
-#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
-
-use anyhow::Result;
-use eframe::*;
-
-mod app;
-mod helpers;
-mod log;
-mod single;
-mod structs;
-mod templates;
-
-pub fn main() -> Result<()> {
-    single::check()?;
-
-    let options = NativeOptions {
-        // viewport: Default::default(),
-        vsync: true,
-        follow_system_theme: true,
-        default_theme: Theme::Dark,
-        // run_and_return: false,
-        // event_loop_builder: None,
-        centered: true,
-        persist_window: true,
-        ..Default::default()
-    };
-
-    run_native(
-        "Dygma Layer Switcher",
-        options,
-        Box::new(|cc| {
-            let app = app::DygmaLayerSwitcher::new(cc);
-            log::init(app.logging);
-            Box::new(app)
-        }),
-    )?;
-
-    Ok(())
-}
diff --git a/dygma-layer-switcher-gui/src/single.rs b/dygma-layer-switcher-gui/src/single.rs
deleted file mode 100644
index fad0b3a..0000000
--- a/dygma-layer-switcher-gui/src/single.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-use anyhow::Result;
-use single_instance::SingleInstance;
-use tracing::error;
-
-pub fn check() -> Result<()> {
-    let instance = SingleInstance::new("dygma-layer-switcher")?;
-
-    if !instance.is_single() {
-        error!("Another instance of Dygma Layer Switcher is already running");
-        std::process::exit(1);
-    }
-
-    Ok(())
-}
diff --git a/dygma-layer-switcher/Cargo.toml b/dygma-layer-switcher/Cargo.toml
index fc1e82d..fa67b52 100644
--- a/dygma-layer-switcher/Cargo.toml
+++ b/dygma-layer-switcher/Cargo.toml
@@ -5,17 +5,32 @@ edition = "2021"
 authors = ["Matthew Wilding <mbwilding@gmail.com>"]
 
 [dependencies]
-common = { path = "../common" }
 anyhow = "1.0"
+dygma_focus = { git = "https://github.com/mbwilding/dygma-focus-api-rs" }
+eframe = { version = "0.24", default-features = false, features = [
+    "default_fonts",
+    "wgpu",
+    "persistence",
+] }
+image = "0.24"
+serde = { version = "1.0", features = ["derive"] }
+single-instance = "0.3"
 tracing = "0.1"
 tracing-appender = "0.2"
-tracing-subscriber = "0.3"
-
-[target.'cfg(windows)'.dependencies]
-windows = { path = "../windows" }
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+tray-icon = "0.11"
+windows = { version = "0.52", features = [
+    "Win32_Foundation",
+    "Win32_UI_Accessibility",
+    "Win32_UI_WindowsAndMessaging",
+    "Win32_System_LibraryLoader",
+    "Win32_System_Threading",
+    "Win32_System_ProcessStatus"
+] }
+winit = "0.29"
 
 [build-dependencies]
 embed-resource = "2.4"
 
 [features]
-no-admin = [] # Disable forced administrator mode [Windows]
+no-admin = [] # Disable forced administrator mode
diff --git a/dygma-layer-switcher-gui/src/app.rs b/dygma-layer-switcher/src/app.rs
similarity index 99%
rename from dygma-layer-switcher-gui/src/app.rs
rename to dygma-layer-switcher/src/app.rs
index cbe5e70..1dc7673 100644
--- a/dygma-layer-switcher-gui/src/app.rs
+++ b/dygma-layer-switcher/src/app.rs
@@ -4,10 +4,9 @@ use crate::templates::*;
 use dygma_focus::Focus;
 use eframe::egui::{CentralPanel, CollapsingHeader, Context, DragValue, TopBottomPanel};
 use eframe::{egui, Frame, Storage};
-use log::warn;
 use serde::{Deserialize, Serialize};
 use std::collections::{BTreeMap, BTreeSet};
-use tracing::error;
+use tracing::{error, warn};
 
 const MAX_LAYERS: u8 = 10;
 
diff --git a/dygma-layer-switcher-gui/src/helpers.rs b/dygma-layer-switcher/src/helpers.rs
similarity index 100%
rename from dygma-layer-switcher-gui/src/helpers.rs
rename to dygma-layer-switcher/src/helpers.rs
diff --git a/dygma-layer-switcher/src/layer.rs b/dygma-layer-switcher/src/layer.rs
new file mode 100644
index 0000000..7ac76c9
--- /dev/null
+++ b/dygma-layer-switcher/src/layer.rs
@@ -0,0 +1,34 @@
+use crate::structs::AppDetails;
+use tracing::{debug, error, info};
+
+pub fn process(app_details: &AppDetails) {
+    debug!("{:?}", app_details);
+
+    // TODO
+    // let config = Config::load();
+
+    // let layer = config
+    //     .check_window(app_details)
+    //     .or_else(|| config.check_process(app_details))
+    //     .or_else(|| config.check_parent(app_details))
+    //     .unwrap_or_else(|| config.base_layer.unwrap_or_default());
+
+    // layer_change(&config, layer);
+}
+
+fn layer_change(layer: u8) {
+    // if let Some(port) = &config.comm_port {
+    //     let mut focus = dygma_focus::Focus::default();
+    //     if focus.open_via_port(port).is_ok() {
+    //         if focus.layer_move_to(layer - 1).is_ok() {
+    //             info!("Changed layer: {}", layer);
+    //         } else {
+    //             error!("Failed to write to serial port: {:?}", &config.comm_port);
+    //         }
+    //     } else {
+    //         error!("Failed to open serial port: {:?}", &config.comm_port);
+    //     }
+    // } else {
+    //     error!("No serial port specified");
+    // }
+}
diff --git a/dygma-layer-switcher/src/log.rs b/dygma-layer-switcher/src/log.rs
index 5a98ec9..5144041 100644
--- a/dygma-layer-switcher/src/log.rs
+++ b/dygma-layer-switcher/src/log.rs
@@ -1,30 +1,32 @@
-use common::config::Config;
-use tracing_subscriber::filter::LevelFilter;
+use tracing_subscriber::filter::{EnvFilter, LevelFilter};
 use tracing_subscriber::fmt;
 use tracing_subscriber::prelude::*;
 
-pub fn init(config: &Config) {
-    if let Some(logging) = config.logging {
-        let console_layer = fmt::layer()
-            .with_ansi(true)
-            .without_time()
-            .compact()
-            .with_filter(LevelFilter::DEBUG);
+pub fn init(logging: bool) {
+    let base_filter = EnvFilter::new("info")
+        .add_directive("dygma-layer-switcher-gui=trace".parse().unwrap())
+        .add_directive("egui=warn".parse().unwrap())
+        .add_directive("wgpu=warn".parse().unwrap());
 
-        let subscriber_builder = tracing_subscriber::registry();
+    let console_layer = fmt::layer()
+        .with_ansi(true)
+        .without_time()
+        .compact()
+        .with_filter(base_filter);
 
-        if logging {
-            subscriber_builder
-                .with(console_layer)
-                .with(
-                    fmt::layer()
-                        .with_ansi(false)
-                        .with_writer(tracing_appender::rolling::daily("logs", "dsl"))
-                        .with_filter(LevelFilter::TRACE),
-                )
-                .init();
-        } else {
-            subscriber_builder.with(console_layer).init();
-        }
+    let subscriber_builder = tracing_subscriber::registry();
+
+    if logging {
+        subscriber_builder
+            .with(console_layer)
+            .with(
+                fmt::layer()
+                    .with_ansi(false)
+                    .with_writer(tracing_appender::rolling::daily("logs", "dsl"))
+                    .with_filter(LevelFilter::DEBUG),
+            )
+            .init();
+    } else {
+        subscriber_builder.with(console_layer).init();
     }
 }
diff --git a/dygma-layer-switcher/src/main.rs b/dygma-layer-switcher/src/main.rs
index 58b209e..f3a5d3e 100644
--- a/dygma-layer-switcher/src/main.rs
+++ b/dygma-layer-switcher/src/main.rs
@@ -1,30 +1,43 @@
 // hide console window on Windows in release
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 
-mod log;
-
-use common::config::Config;
-use common::single;
-use tracing::error;
-
-fn main() -> anyhow::Result<()> {
-    let config = Config::load();
-    log::init(&config);
-
-    #[cfg(not(windows))]
-    error!("Platform not yet supported");
+use anyhow::Result;
+use eframe::*;
 
+mod app;
+mod helpers;
+mod log;
+mod single;
+mod structs;
+mod templates;
+mod windows;
+mod layer;
+mod tray;
+
+pub fn main() -> Result<()> {
     single::check()?;
 
-    #[cfg(windows)]
-    {
-        windows::init::start();
-
-        windows::tray::load().unwrap_or_else(|e| {
-            error!("Failed to load tray: {}", e);
-            std::process::exit(1);
-        });
-    }
+    let options = NativeOptions {
+        // viewport: Default::default(),
+        vsync: true,
+        follow_system_theme: true,
+        default_theme: Theme::Dark,
+        // run_and_return: false,
+        // event_loop_builder: None,
+        centered: false,
+        persist_window: true,
+        ..Default::default()
+    };
+
+    run_native(
+        "Dygma Layer Switcher",
+        options,
+        Box::new(|cc| {
+            let app = app::DygmaLayerSwitcher::new(cc);
+            log::init(app.logging);
+            Box::new(app)
+        }),
+    )?;
 
     Ok(())
 }
diff --git a/common/src/single.rs b/dygma-layer-switcher/src/single.rs
similarity index 100%
rename from common/src/single.rs
rename to dygma-layer-switcher/src/single.rs
diff --git a/dygma-layer-switcher-gui/src/structs.rs b/dygma-layer-switcher/src/structs.rs
similarity index 94%
rename from dygma-layer-switcher-gui/src/structs.rs
rename to dygma-layer-switcher/src/structs.rs
index e6ac23c..710af62 100644
--- a/dygma-layer-switcher-gui/src/structs.rs
+++ b/dygma-layer-switcher/src/structs.rs
@@ -124,3 +124,9 @@ impl Exclude {
         }
     }
 }
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize)]
+pub struct AppDetails {
+    pub window: String,
+    pub process: String,
+}
diff --git a/dygma-layer-switcher-gui/src/templates.rs b/dygma-layer-switcher/src/templates.rs
similarity index 100%
rename from dygma-layer-switcher-gui/src/templates.rs
rename to dygma-layer-switcher/src/templates.rs
diff --git a/windows/src/tray.rs b/dygma-layer-switcher/src/tray.rs
similarity index 100%
rename from windows/src/tray.rs
rename to dygma-layer-switcher/src/tray.rs
diff --git a/dygma-layer-switcher/src/windows.rs b/dygma-layer-switcher/src/windows.rs
new file mode 100644
index 0000000..709ca49
--- /dev/null
+++ b/dygma-layer-switcher/src/windows.rs
@@ -0,0 +1,155 @@
+use crate::layer;
+use crate::structs::AppDetails;
+use std::path::Path;
+use std::sync::atomic::AtomicU32;
+use std::sync::atomic::Ordering;
+use tracing::{error, info, trace};
+use windows::core::PCWSTR;
+use windows::Win32::{
+    Foundation::{HWND, MAX_PATH},
+    System::{
+        LibraryLoader::GetModuleHandleW,
+        ProcessStatus::K32GetModuleFileNameExW,
+        Threading::{OpenProcess, PROCESS_QUERY_INFORMATION, PROCESS_VM_READ},
+    },
+    UI::{
+        Accessibility::{SetWinEventHook, HWINEVENTHOOK},
+        WindowsAndMessaging::{
+            GetMessageW, GetWindowTextLengthW, GetWindowTextW, GetWindowThreadProcessId,
+            EVENT_OBJECT_FOCUS, MSG, WINEVENT_OUTOFCONTEXT,
+        },
+    },
+};
+
+/// # Safety
+///
+/// WinAPI.
+pub unsafe fn hydrate(window_handle: HWND) -> AppDetails {
+    AppDetails {
+        window: get_window(window_handle),
+        process: get_process(window_handle),
+    }
+}
+
+/// # Safety
+///
+/// WinAPI.
+unsafe fn get_process(window_handle: HWND) -> String {
+    let mut process_id: u32 = 0;
+
+    let thread_id = GetWindowThreadProcessId(window_handle, Some(&mut process_id as *mut u32));
+
+    if thread_id == 0 {
+        error!("Failed to retrieve process ID");
+        return String::new();
+    };
+
+    let process_handle = match OpenProcess(
+        PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
+        false,
+        process_id,
+    ) {
+        Ok(handle) => handle,
+        Err(e) => {
+            error!("Failed to open process: {:?}", e);
+            return String::new();
+        }
+    };
+
+    trace!("Process handle: {:?}", process_handle.0);
+
+    let mut exe_path_bytes: Vec<u16> = vec![0; MAX_PATH as usize];
+    let exe_path_length = K32GetModuleFileNameExW(process_handle, None, &mut exe_path_bytes);
+    let exe_path = String::from_utf16_lossy(&exe_path_bytes[..exe_path_length as usize]);
+
+    trace!("Process: {:?}", exe_path);
+
+    let process = if let Some(file_name) = Path::new(&exe_path).file_name() {
+        if let Some(file_name_str) = file_name.to_str() {
+            file_name_str.to_owned()
+        } else {
+            error!("Failed to convert the executable name to string");
+            return String::new();
+        }
+    } else {
+        error!("Failed to extract the executable name from the path");
+        return String::new();
+    };
+    trace!("Executable name: {:?}", process);
+
+    process
+}
+
+/// # Safety
+///
+/// WinAPI.
+unsafe fn get_window(h_wnd: HWND) -> String {
+    let title_length = GetWindowTextLengthW(h_wnd) + 1;
+    let mut window: Vec<u16> = vec![0; title_length as usize];
+    let _ = GetWindowTextW(h_wnd, window.as_mut_slice());
+    let window = String::from_utf16_lossy(&window[..title_length as usize - 1]);
+    trace!("Window: {:?}", window);
+
+    window
+}
+
+static DEBOUNCER: AtomicU32 = AtomicU32::new(0);
+
+/// # Safety
+///
+/// WinAPI.
+pub unsafe extern "system" fn get_focused_window_details(
+    _h_win_event_hook: HWINEVENTHOOK,
+    _event: u32,
+    window_handle: HWND,
+    _id_object: i32,
+    _id_child: i32,
+    _id_event_thread: u32,
+    dwms_event_time: u32,
+) {
+    if window_handle.0 == 0 {
+        return;
+    }
+
+    if dwms_event_time == DEBOUNCER.load(Ordering::SeqCst) {
+        return;
+    }
+
+    DEBOUNCER.store(dwms_event_time, Ordering::SeqCst);
+
+    let app_details = hydrate(window_handle);
+    layer::process(&app_details);
+}
+
+pub fn start() {
+    std::thread::spawn(|| {
+        unsafe {
+            info!("Attempting Hook");
+
+            let module_handle = GetModuleHandleW(PCWSTR::null()).unwrap_or_else(|e| {
+                error!("Failed to get module handle: {:?}", e);
+                std::process::exit(1);
+            });
+
+            let _event_hook = SetWinEventHook(
+                EVENT_OBJECT_FOCUS,
+                EVENT_OBJECT_FOCUS,
+                module_handle,
+                Some(get_focused_window_details),
+                0,
+                0,
+                WINEVENT_OUTOFCONTEXT,
+            );
+
+            info!("Hooked");
+
+            let mut msg = MSG::default();
+
+            loop {
+                // Will wait here for a message, so no sleep is needed in the loop
+                // This is a blocking call, but is required for the hook to work
+                while GetMessageW(&mut msg, HWND(0), 0, 0).as_bool() {}
+            }
+        }
+    });
+}
diff --git a/windows/Cargo.toml b/windows/Cargo.toml
deleted file mode 100644
index 6b11721..0000000
--- a/windows/Cargo.toml
+++ /dev/null
@@ -1,21 +0,0 @@
-[package]
-name = "windows"
-version = "0.1.0"
-edition = "2021"
-authors = ["Matthew Wilding <mbwilding@gmail.com>"]
-
-[target.'cfg(target_os = "windows")'.dependencies]
-common = { path = "../common" }
-anyhow = "1.0"
-image = "0.24"
-tracing = "0.1"
-tray-icon = "0.11"
-windows = { version = "0.52", features = [
-    "Win32_Foundation",
-    "Win32_UI_Accessibility",
-    "Win32_UI_WindowsAndMessaging",
-    "Win32_System_LibraryLoader",
-    "Win32_System_Threading",
-    "Win32_System_ProcessStatus"
-] }
-winit = "0.29"
diff --git a/windows/src/collection.rs b/windows/src/collection.rs
deleted file mode 100644
index 72068dd..0000000
--- a/windows/src/collection.rs
+++ /dev/null
@@ -1,91 +0,0 @@
-use common::config::AppDetails;
-use std::path::Path;
-use tracing::{error, trace};
-use windows::Win32::{
-    Foundation::{HWND, MAX_PATH},
-    System::{
-        ProcessStatus::K32GetModuleFileNameExW,
-        Threading::{OpenProcess, PROCESS_QUERY_INFORMATION, PROCESS_VM_READ},
-    },
-    UI::WindowsAndMessaging::{GetWindowTextLengthW, GetWindowTextW, GetWindowThreadProcessId},
-};
-
-/// # Safety
-///
-/// WinAPI.
-pub unsafe fn hydrate(window_handle: HWND) -> AppDetails {
-    AppDetails {
-        window: get_window(window_handle),
-        process: get_process(window_handle),
-    }
-}
-
-/// # Safety
-///
-/// WinAPI.
-unsafe fn get_process(window_handle: HWND) -> Option<String> {
-    let mut process_id: u32 = 0;
-
-    let thread_id = GetWindowThreadProcessId(window_handle, Some(&mut process_id as *mut u32));
-
-    if thread_id == 0 {
-        error!("Failed to retrieve process ID");
-        return None;
-    };
-
-    let process_handle = match OpenProcess(
-        PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
-        false,
-        process_id,
-    ) {
-        Ok(handle) => handle,
-        Err(e) => {
-            error!("Failed to open process: {:?}", e);
-            return None;
-        }
-    };
-
-    trace!("Process handle: {:?}", process_handle.0);
-
-    let mut exe_path_bytes: Vec<u16> = vec![0; MAX_PATH as usize];
-    let exe_path_length = K32GetModuleFileNameExW(process_handle, None, &mut exe_path_bytes);
-    let exe_path = String::from_utf16_lossy(&exe_path_bytes[..exe_path_length as usize]);
-
-    trace!("Process: {:?}", exe_path);
-
-    let process = if let Some(file_name) = Path::new(&exe_path).file_name() {
-        if let Some(file_name_str) = file_name.to_str() {
-            file_name_str.to_owned()
-        } else {
-            error!("Failed to convert the executable name to string");
-            return None;
-        }
-    } else {
-        error!("Failed to extract the executable name from the path");
-        return None;
-    };
-    trace!("Executable name: {:?}", process);
-
-    if process.is_empty() {
-        return None;
-    }
-
-    Some(process)
-}
-
-/// # Safety
-///
-/// WinAPI.
-unsafe fn get_window(h_wnd: HWND) -> Option<String> {
-    let title_length = GetWindowTextLengthW(h_wnd) + 1;
-    let mut window: Vec<u16> = vec![0; title_length as usize];
-    let _ = GetWindowTextW(h_wnd, window.as_mut_slice());
-    let window = String::from_utf16_lossy(&window[..title_length as usize - 1]);
-    trace!("Window: {:?}", window);
-
-    if window.is_empty() {
-        return None;
-    }
-
-    Some(window)
-}
diff --git a/windows/src/init.rs b/windows/src/init.rs
deleted file mode 100644
index 850bd6b..0000000
--- a/windows/src/init.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-use crate::message_loop::get_focused_window_details;
-use tracing::{error, info};
-use windows::{
-    core::PCWSTR,
-    Win32::{
-        Foundation::HWND,
-        System::LibraryLoader::GetModuleHandleW,
-        UI::{
-            Accessibility::SetWinEventHook,
-            WindowsAndMessaging::{GetMessageW, EVENT_OBJECT_FOCUS, MSG, WINEVENT_OUTOFCONTEXT},
-        },
-    },
-};
-
-pub fn start() {
-    std::thread::spawn(|| {
-        unsafe {
-            info!("Attempting Hook");
-
-            let module_handle = GetModuleHandleW(PCWSTR::null()).unwrap_or_else(|e| {
-                error!("Failed to get module handle: {:?}", e);
-                std::process::exit(1);
-            });
-
-            let _event_hook = SetWinEventHook(
-                EVENT_OBJECT_FOCUS,
-                EVENT_OBJECT_FOCUS,
-                module_handle,
-                Some(get_focused_window_details),
-                0,
-                0,
-                WINEVENT_OUTOFCONTEXT,
-            );
-
-            info!("Hooked");
-
-            let mut msg = MSG::default();
-
-            loop {
-                // Will wait here for a message, so no sleep is needed in the loop
-                // This is a blocking call, but is required for the hook to work
-                while GetMessageW(&mut msg, HWND(0), 0, 0).as_bool() {}
-            }
-        }
-    });
-}
diff --git a/windows/src/lib.rs b/windows/src/lib.rs
deleted file mode 100644
index d5a295c..0000000
--- a/windows/src/lib.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-#[cfg(target_os = "windows")]
-pub mod collection;
-
-#[cfg(target_os = "windows")]
-pub mod init;
-
-#[cfg(target_os = "windows")]
-pub mod message_loop;
-
-#[cfg(target_os = "windows")]
-pub mod tray;
diff --git a/windows/src/message_loop.rs b/windows/src/message_loop.rs
deleted file mode 100644
index e810eb9..0000000
--- a/windows/src/message_loop.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-use crate::collection;
-use std::sync::atomic::AtomicU32;
-use std::sync::atomic::Ordering;
-use windows::Win32::Foundation::HWND;
-use windows::Win32::UI::Accessibility::HWINEVENTHOOK;
-
-static DEBOUNCER: AtomicU32 = AtomicU32::new(0);
-
-/// # Safety
-///
-/// WinAPI.
-pub unsafe extern "system" fn get_focused_window_details(
-    _h_win_event_hook: HWINEVENTHOOK,
-    _event: u32,
-    window_handle: HWND,
-    _id_object: i32,
-    _id_child: i32,
-    _id_event_thread: u32,
-    dwms_event_time: u32,
-) {
-    if window_handle.0 == 0 {
-        return;
-    }
-
-    if dwms_event_time == DEBOUNCER.load(Ordering::SeqCst) {
-        return;
-    }
-
-    DEBOUNCER.store(dwms_event_time, Ordering::SeqCst);
-
-    let app_details = collection::hydrate(window_handle);
-    common::layer::process(&app_details);
-}

From 9cd07af915214dbb443fd72139884d3ee1b4d5db Mon Sep 17 00:00:00 2001
From: Matthew Wilding <mbwilding@gmail.com>
Date: Sat, 16 Dec 2023 15:54:40 +0800
Subject: [PATCH 17/39] Tray

---
 dygma-layer-switcher/src/app.rs       | 11 ++++++
 dygma-layer-switcher/src/log.rs       |  5 +--
 dygma-layer-switcher/src/main.rs      | 37 +++++++++++++-----
 dygma-layer-switcher/src/single.rs    |  3 +-
 dygma-layer-switcher/src/templates.rs | 10 +----
 dygma-layer-switcher/src/tray.rs      | 54 ++-------------------------
 6 files changed, 48 insertions(+), 72 deletions(-)

diff --git a/dygma-layer-switcher/src/app.rs b/dygma-layer-switcher/src/app.rs
index 1dc7673..3aaab82 100644
--- a/dygma-layer-switcher/src/app.rs
+++ b/dygma-layer-switcher/src/app.rs
@@ -7,6 +7,8 @@ use eframe::{egui, Frame, Storage};
 use serde::{Deserialize, Serialize};
 use std::collections::{BTreeMap, BTreeSet};
 use tracing::{error, warn};
+use tray_icon::menu::{MenuEvent, MenuId};
+use tray_icon::TrayIconEvent;
 
 const MAX_LAYERS: u8 = 10;
 
@@ -294,6 +296,15 @@ impl DygmaLayerSwitcher {
 
 impl eframe::App for DygmaLayerSwitcher {
     fn update(&mut self, ctx: &Context, _frame: &mut Frame) {
+        if let Ok(event) = TrayIconEvent::receiver().try_recv() {
+            println!("tray event: {event:?}");
+        }
+        if let Ok(event) = MenuEvent::receiver().try_recv() {
+            // Exit
+            if event.id == "1001" {
+                ctx.send_viewport_cmd(egui::ViewportCommand::Close);
+            }
+        }
         self.top_panel(ctx);
         self.central_panel(ctx);
     }
diff --git a/dygma-layer-switcher/src/log.rs b/dygma-layer-switcher/src/log.rs
index 5144041..c16dec4 100644
--- a/dygma-layer-switcher/src/log.rs
+++ b/dygma-layer-switcher/src/log.rs
@@ -4,7 +4,7 @@ use tracing_subscriber::prelude::*;
 
 pub fn init(logging: bool) {
     let base_filter = EnvFilter::new("info")
-        .add_directive("dygma-layer-switcher-gui=trace".parse().unwrap())
+        .add_directive("dygma-layer-switcher=trace".parse().unwrap())
         .add_directive("egui=warn".parse().unwrap())
         .add_directive("wgpu=warn".parse().unwrap());
 
@@ -22,8 +22,7 @@ pub fn init(logging: bool) {
             .with(
                 fmt::layer()
                     .with_ansi(false)
-                    .with_writer(tracing_appender::rolling::daily("logs", "dsl"))
-                    .with_filter(LevelFilter::DEBUG),
+                    .with_writer(tracing_appender::rolling::daily("logs", "dsl")),
             )
             .init();
     } else {
diff --git a/dygma-layer-switcher/src/main.rs b/dygma-layer-switcher/src/main.rs
index f3a5d3e..44ce45b 100644
--- a/dygma-layer-switcher/src/main.rs
+++ b/dygma-layer-switcher/src/main.rs
@@ -3,36 +3,55 @@
 
 use anyhow::Result;
 use eframe::*;
+use std::{cell::RefCell, rc::Rc};
+use tray_icon::menu::{Menu, MenuItem};
+use tray_icon::TrayIconBuilder;
 
 mod app;
 mod helpers;
+mod layer;
 mod log;
 mod single;
 mod structs;
 mod templates;
-mod windows;
-mod layer;
 mod tray;
+mod windows;
+
+pub const TITLE: &str = "Dygma Layer Switcher";
 
 pub fn main() -> Result<()> {
     single::check()?;
 
+    let icon = tray::load_icon("assets/icons/icon.ico")?;
+    let mut _tray_icon = Rc::new(RefCell::new(None));
+    let tray_rc = _tray_icon.clone();
+
+    let tray_menu = Menu::new();
+    tray_menu
+        .append(&MenuItem::new("Quit", true, None))
+        .expect("Failed to append menu item");
+
     let options = NativeOptions {
-        // viewport: Default::default(),
-        vsync: true,
-        follow_system_theme: true,
         default_theme: Theme::Dark,
-        // run_and_return: false,
-        // event_loop_builder: None,
-        centered: false,
+        follow_system_theme: true,
         persist_window: true,
+        centered: false,
+        vsync: true,
         ..Default::default()
     };
 
     run_native(
         "Dygma Layer Switcher",
         options,
-        Box::new(|cc| {
+        Box::new(move |cc| {
+            tray_rc.borrow_mut().replace(
+                TrayIconBuilder::new()
+                    .with_menu(Box::new(tray_menu))
+                    .with_tooltip(TITLE)
+                    .with_icon(icon)
+                    .build()
+                    .unwrap(),
+            );
             let app = app::DygmaLayerSwitcher::new(cc);
             log::init(app.logging);
             Box::new(app)
diff --git a/dygma-layer-switcher/src/single.rs b/dygma-layer-switcher/src/single.rs
index fad0b3a..e344a55 100644
--- a/dygma-layer-switcher/src/single.rs
+++ b/dygma-layer-switcher/src/single.rs
@@ -1,9 +1,10 @@
+use crate::TITLE;
 use anyhow::Result;
 use single_instance::SingleInstance;
 use tracing::error;
 
 pub fn check() -> Result<()> {
-    let instance = SingleInstance::new("dygma-layer-switcher")?;
+    let instance = SingleInstance::new(TITLE)?;
 
     if !instance.is_single() {
         error!("Another instance of Dygma Layer Switcher is already running");
diff --git a/dygma-layer-switcher/src/templates.rs b/dygma-layer-switcher/src/templates.rs
index d6e2d9b..682a675 100644
--- a/dygma-layer-switcher/src/templates.rs
+++ b/dygma-layer-switcher/src/templates.rs
@@ -2,10 +2,7 @@ use eframe::egui;
 
 pub fn editable_label(ui: &mut egui::Ui, value: &mut String, editing: &mut bool) {
     if *editing {
-        if ui
-            .text_edit_singleline(value)
-            .lost_focus()
-        {
+        if ui.text_edit_singleline(value).lost_focus() {
             *editing = false;
         }
     } else if ui.button(value.as_str()).clicked() {
@@ -20,10 +17,7 @@ pub fn editable_collapsing<F: FnMut(&mut egui::Ui)>(
     mut content: F,
 ) {
     if *editing {
-        if ui
-            .text_edit_singleline(value)
-            .lost_focus()
-        {
+        if ui.text_edit_singleline(value).lost_focus() {
             *editing = false;
         }
     } else {
diff --git a/dygma-layer-switcher/src/tray.rs b/dygma-layer-switcher/src/tray.rs
index 1b17c2e..4a66e32 100644
--- a/dygma-layer-switcher/src/tray.rs
+++ b/dygma-layer-switcher/src/tray.rs
@@ -1,13 +1,7 @@
-use anyhow::{Context, Result};
-use std::path::Path;
-use tracing::trace;
-use tray_icon::menu::{Menu, MenuEvent, MenuItem};
-use tray_icon::{Icon, TrayIconBuilder, TrayIconEvent};
-use winit::event_loop::{ControlFlow, EventLoopBuilder};
+use anyhow::Result;
+use tray_icon::Icon;
 
-const TITLE: &str = "Dygma Layer Switcher";
-
-fn load_icon(path: &Path) -> Result<Icon> {
+pub fn load_icon(path: &str) -> Result<Icon> {
     let (icon_rgba, icon_width, icon_height) = {
         let image = image::open(path)?.into_rgba8();
         let (width, height) = image.dimensions();
@@ -18,45 +12,3 @@ fn load_icon(path: &Path) -> Result<Icon> {
 
     Ok(icon)
 }
-
-pub fn load() -> Result<()> {
-    let icon_path = "assets/icons/icon.ico";
-    let icon =
-        load_icon(Path::new(&icon_path)).context(format!("Could not find icon: {}", &icon_path))?;
-
-    let event_loop = EventLoopBuilder::new().build()?;
-
-    let menu_channel = MenuEvent::receiver();
-    let tray_channel = TrayIconEvent::receiver();
-
-    let item_quit = MenuItem::new("Quit", true, None);
-
-    let tray_menu = Menu::new();
-    tray_menu
-        .append(&item_quit)
-        .context("Failed to append menu item")?;
-
-    let _tray_icon = TrayIconBuilder::new()
-        .with_menu(Box::new(tray_menu))
-        .with_tooltip(TITLE)
-        .with_icon(icon)
-        .build()?;
-
-    event_loop.run(move |_event, event_loop| {
-        event_loop.set_control_flow(ControlFlow::Wait);
-
-        if let Ok(event) = tray_channel.try_recv() {
-            trace!("{:#?}", event);
-        }
-
-        if let Ok(event) = menu_channel.try_recv() {
-            trace!("{:#?}", event);
-
-            if event.id == item_quit.id() {
-                event_loop.exit();
-            }
-        }
-    })?;
-
-    Ok(())
-}

From 402f40b3f3809ade34dc71208a06ad4d76b08866 Mon Sep 17 00:00:00 2001
From: Matthew Wilding <mbwilding@gmail.com>
Date: Sat, 16 Dec 2023 16:01:07 +0800
Subject: [PATCH 18/39] Last part to do is process

---
 dygma-layer-switcher/src/main.rs    | 1 +
 dygma-layer-switcher/src/windows.rs | 2 ++
 2 files changed, 3 insertions(+)

diff --git a/dygma-layer-switcher/src/main.rs b/dygma-layer-switcher/src/main.rs
index 44ce45b..5c1e87f 100644
--- a/dygma-layer-switcher/src/main.rs
+++ b/dygma-layer-switcher/src/main.rs
@@ -54,6 +54,7 @@ pub fn main() -> Result<()> {
             );
             let app = app::DygmaLayerSwitcher::new(cc);
             log::init(app.logging);
+            windows::start();
             Box::new(app)
         }),
     )?;
diff --git a/dygma-layer-switcher/src/windows.rs b/dygma-layer-switcher/src/windows.rs
index 709ca49..21572b9 100644
--- a/dygma-layer-switcher/src/windows.rs
+++ b/dygma-layer-switcher/src/windows.rs
@@ -111,6 +111,8 @@ pub unsafe extern "system" fn get_focused_window_details(
         return;
     }
 
+    trace!("window_handle: {:?}", window_handle);
+
     if dwms_event_time == DEBOUNCER.load(Ordering::SeqCst) {
         return;
     }

From af77e1419e8b890cd71e6caa80fc0b6066ceca1c Mon Sep 17 00:00:00 2001
From: Matthew Wilding <mbwilding@gmail.com>
Date: Sun, 17 Dec 2023 00:44:37 +0800
Subject: [PATCH 19/39] Embedded tray icon

---
 dygma-layer-switcher/src/app.rs  | 23 +++++++++++++++++++----
 dygma-layer-switcher/src/main.rs |  4 +++-
 dygma-layer-switcher/src/tray.rs |  6 ++++--
 3 files changed, 26 insertions(+), 7 deletions(-)

diff --git a/dygma-layer-switcher/src/app.rs b/dygma-layer-switcher/src/app.rs
index 3aaab82..d1d3657 100644
--- a/dygma-layer-switcher/src/app.rs
+++ b/dygma-layer-switcher/src/app.rs
@@ -6,9 +6,9 @@ use eframe::egui::{CentralPanel, CollapsingHeader, Context, DragValue, TopBottom
 use eframe::{egui, Frame, Storage};
 use serde::{Deserialize, Serialize};
 use std::collections::{BTreeMap, BTreeSet};
-use tracing::{error, warn};
-use tray_icon::menu::{MenuEvent, MenuId};
-use tray_icon::TrayIconEvent;
+use tracing::{error, trace, warn};
+use tray_icon::menu::MenuEvent;
+use tray_icon::{ClickType, TrayIconEvent};
 
 const MAX_LAYERS: u8 = 10;
 
@@ -32,6 +32,9 @@ pub struct DygmaLayerSwitcher {
 
     #[serde(skip)]
     pub remove_hidden_layer: Option<u8>,
+
+    #[serde(skip)]
+    pub window_visible: bool,
 }
 
 impl Default for DygmaLayerSwitcher {
@@ -58,6 +61,7 @@ impl Default for DygmaLayerSwitcher {
             remove_app: None,
             remove_exclude: None,
             remove_hidden_layer: None,
+            window_visible: true,
         }
     }
 }
@@ -297,9 +301,20 @@ impl DygmaLayerSwitcher {
 impl eframe::App for DygmaLayerSwitcher {
     fn update(&mut self, ctx: &Context, _frame: &mut Frame) {
         if let Ok(event) = TrayIconEvent::receiver().try_recv() {
-            println!("tray event: {event:?}");
+            trace!("Tray icon event: {event:?}");
+            match event.click_type {
+                ClickType::Left => {}
+                ClickType::Right => {
+                    // Menu
+                }
+                ClickType::Double => {
+                    self.window_visible = !self.window_visible;
+                    ctx.send_viewport_cmd(egui::ViewportCommand::Visible(self.window_visible))
+                }
+            }
         }
         if let Ok(event) = MenuEvent::receiver().try_recv() {
+            trace!("Tray menu event: {event:?}");
             // Exit
             if event.id == "1001" {
                 ctx.send_viewport_cmd(egui::ViewportCommand::Close);
diff --git a/dygma-layer-switcher/src/main.rs b/dygma-layer-switcher/src/main.rs
index 5c1e87f..8623f49 100644
--- a/dygma-layer-switcher/src/main.rs
+++ b/dygma-layer-switcher/src/main.rs
@@ -2,6 +2,7 @@
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 
 use anyhow::Result;
+use eframe::egui::ViewportBuilder;
 use eframe::*;
 use std::{cell::RefCell, rc::Rc};
 use tray_icon::menu::{Menu, MenuItem};
@@ -18,11 +19,12 @@ mod tray;
 mod windows;
 
 pub const TITLE: &str = "Dygma Layer Switcher";
+pub const ICON: &[u8] = include_bytes!("../../assets/icons/icon.ico");
 
 pub fn main() -> Result<()> {
     single::check()?;
 
-    let icon = tray::load_icon("assets/icons/icon.ico")?;
+    let icon = tray::load_tray_icon(ICON)?;
     let mut _tray_icon = Rc::new(RefCell::new(None));
     let tray_rc = _tray_icon.clone();
 
diff --git a/dygma-layer-switcher/src/tray.rs b/dygma-layer-switcher/src/tray.rs
index 4a66e32..f1a41bf 100644
--- a/dygma-layer-switcher/src/tray.rs
+++ b/dygma-layer-switcher/src/tray.rs
@@ -1,9 +1,11 @@
 use anyhow::Result;
 use tray_icon::Icon;
 
-pub fn load_icon(path: &str) -> Result<Icon> {
+pub fn load_tray_icon(bytes: &[u8]) -> Result<Icon> {
     let (icon_rgba, icon_width, icon_height) = {
-        let image = image::open(path)?.into_rgba8();
+        let image = image::load_from_memory(bytes)
+            .expect("Failed to open icon path")
+            .into_rgba8();
         let (width, height) = image.dimensions();
         let rgba = image.into_raw();
         (rgba, width, height)

From 4ad5a74d13bab4584c2b7acbfbe79a1be07f2112 Mon Sep 17 00:00:00 2001
From: Matthew Wilding <mbwilding@gmail.com>
Date: Sun, 17 Dec 2023 01:16:31 +0800
Subject: [PATCH 20/39] Fixed app icon

---
 .../src/{tray.rs => images.rs}                | 15 +++++++++--
 dygma-layer-switcher/src/layer.rs             |  2 +-
 dygma-layer-switcher/src/main.rs              | 26 ++++++++++---------
 3 files changed, 28 insertions(+), 15 deletions(-)
 rename dygma-layer-switcher/src/{tray.rs => images.rs} (60%)

diff --git a/dygma-layer-switcher/src/tray.rs b/dygma-layer-switcher/src/images.rs
similarity index 60%
rename from dygma-layer-switcher/src/tray.rs
rename to dygma-layer-switcher/src/images.rs
index f1a41bf..974f6c8 100644
--- a/dygma-layer-switcher/src/tray.rs
+++ b/dygma-layer-switcher/src/images.rs
@@ -1,7 +1,15 @@
 use anyhow::Result;
+use eframe::egui::IconData;
 use tray_icon::Icon;
 
 pub fn load_tray_icon(bytes: &[u8]) -> Result<Icon> {
+    let icon = load_icon(bytes);
+    let icon = Icon::from_rgba(icon.rgba, icon.width, icon.height)?;
+
+    Ok(icon)
+}
+
+pub fn load_icon(bytes: &[u8]) -> IconData {
     let (icon_rgba, icon_width, icon_height) = {
         let image = image::load_from_memory(bytes)
             .expect("Failed to open icon path")
@@ -10,7 +18,10 @@ pub fn load_tray_icon(bytes: &[u8]) -> Result<Icon> {
         let rgba = image.into_raw();
         (rgba, width, height)
     };
-    let icon = Icon::from_rgba(icon_rgba, icon_width, icon_height)?;
 
-    Ok(icon)
+    IconData {
+        rgba: icon_rgba,
+        width: icon_width,
+        height: icon_height,
+    }
 }
diff --git a/dygma-layer-switcher/src/layer.rs b/dygma-layer-switcher/src/layer.rs
index 7ac76c9..f5391df 100644
--- a/dygma-layer-switcher/src/layer.rs
+++ b/dygma-layer-switcher/src/layer.rs
@@ -1,5 +1,5 @@
 use crate::structs::AppDetails;
-use tracing::{debug, error, info};
+use tracing::debug;
 
 pub fn process(app_details: &AppDetails) {
     debug!("{:?}", app_details);
diff --git a/dygma-layer-switcher/src/main.rs b/dygma-layer-switcher/src/main.rs
index 8623f49..fe1b763 100644
--- a/dygma-layer-switcher/src/main.rs
+++ b/dygma-layer-switcher/src/main.rs
@@ -4,18 +4,19 @@
 use anyhow::Result;
 use eframe::egui::ViewportBuilder;
 use eframe::*;
+use std::sync::Arc;
 use std::{cell::RefCell, rc::Rc};
 use tray_icon::menu::{Menu, MenuItem};
 use tray_icon::TrayIconBuilder;
 
 mod app;
 mod helpers;
+mod images;
 mod layer;
 mod log;
 mod single;
 mod structs;
 mod templates;
-mod tray;
 mod windows;
 
 pub const TITLE: &str = "Dygma Layer Switcher";
@@ -24,27 +25,28 @@ pub const ICON: &[u8] = include_bytes!("../../assets/icons/icon.ico");
 pub fn main() -> Result<()> {
     single::check()?;
 
-    let icon = tray::load_tray_icon(ICON)?;
+    let icon = images::load_tray_icon(ICON)?;
     let mut _tray_icon = Rc::new(RefCell::new(None));
     let tray_rc = _tray_icon.clone();
 
+    egui::IconData::default();
+
     let tray_menu = Menu::new();
     tray_menu
         .append(&MenuItem::new("Quit", true, None))
         .expect("Failed to append menu item");
 
-    let options = NativeOptions {
-        default_theme: Theme::Dark,
-        follow_system_theme: true,
-        persist_window: true,
-        centered: false,
-        vsync: true,
-        ..Default::default()
-    };
-
     run_native(
         "Dygma Layer Switcher",
-        options,
+        NativeOptions {
+            default_theme: Theme::Dark,
+            follow_system_theme: true,
+            persist_window: true,
+            centered: false,
+            vsync: true,
+            viewport: { ViewportBuilder::default().with_icon(Arc::new(images::load_icon(ICON))) },
+            ..Default::default()
+        },
         Box::new(move |cc| {
             tray_rc.borrow_mut().replace(
                 TrayIconBuilder::new()

From e2239d8da0c2a4c1d8c955fb013d0590e81524fa Mon Sep 17 00:00:00 2001
From: Matthew Wilding <mbwilding@gmail.com>
Date: Sun, 17 Dec 2023 01:19:21 +0800
Subject: [PATCH 21/39] CI

---
 .github/workflows/Release-Windows.yml |  4 +--
 .github/workflows/Validate.yml        | 51 ++++-----------------------
 2 files changed, 8 insertions(+), 47 deletions(-)

diff --git a/.github/workflows/Release-Windows.yml b/.github/workflows/Release-Windows.yml
index 7ca6e9f..0879d5d 100644
--- a/.github/workflows/Release-Windows.yml
+++ b/.github/workflows/Release-Windows.yml
@@ -10,7 +10,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        target: ["x86_64-pc-windows-gnu"] # Waiting for `aarch64-pc-windows-gnu` to be available.
+        target: ["x86_64-pc-windows-gnu"]
 
     steps:
       - name: "Checkout"
@@ -31,7 +31,7 @@ jobs:
       - name: "Zip"
         run: |
           cp target/${{ matrix.target }}/release/dygma-layer-switcher.exe .
-          zip windows-${{ github.ref_name }}-${{ matrix.target }}.zip readme.md dygma-layer-switcher.exe assets/icons/icon.ico
+          zip windows-${{ github.ref_name }}-${{ matrix.target }}.zip readme.md dygma-layer-switcher.exe
 
       - name: "Release"
         uses: softprops/action-gh-release@v1
diff --git a/.github/workflows/Validate.yml b/.github/workflows/Validate.yml
index 2ae35e1..f8ad9ed 100644
--- a/.github/workflows/Validate.yml
+++ b/.github/workflows/Validate.yml
@@ -10,8 +10,8 @@ env:
   APT_PACKAGES: libatk1.0-dev libpango1.0-dev libgtk-3-dev libudev-dev libxdo-dev
 
 jobs:
-  formatting:
-    name: "Format"
+  checks:
+    name: "Checks"
     runs-on: ubuntu-latest
 
     steps:
@@ -22,52 +22,13 @@ jobs:
         uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: stable
-          components: rustfmt
-
-      - name: "Format"
-        run: cargo fmt -- --check
-
-  clippy:
-    name: "Clippy"
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: "Checkout"
-        uses: actions/checkout@master
-
-      - name: "Rust"
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          toolchain: stable
-          components: clippy
+          components: rustfmt, clippy
 
       - name: "Dependencies"
         run: sudo apt-get install -y ${{ env.APT_PACKAGES }}
 
+      - name: "Format"
+        run: cargo fmt -- --check
+
       - name: "Clippy"
         run: cargo clippy -- -D warnings
-
-  check:
-    name: "Check"
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        target: ["x86_64-pc-windows-gnu", "x86_64-unknown-linux-gnu"]
-
-    steps:
-      - name: "Checkout"
-        uses: actions/checkout@master
-
-      - name: "Rust"
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          toolchain: stable
-          targets: ${{ matrix.target }}
-
-      - name: "Dependencies"
-        if: contains(matrix.target, 'linux')
-        run: sudo apt-get install -y ${{ env.APT_PACKAGES }}
-
-      - name: "Check"
-        run: cargo check --target ${{ matrix.target }}

From 0d47c3325e1caceb013d5c704c09ac74def21a68 Mon Sep 17 00:00:00 2001
From: Matthew Wilding <mbwilding@gmail.com>
Date: Sun, 17 Dec 2023 01:24:57 +0800
Subject: [PATCH 22/39] Clean up, TODO investigate bug where deleting the last
 exclude causes a panic

---
 dygma-layer-switcher/src/{images.rs => icon.rs} | 0
 dygma-layer-switcher/src/main.rs                | 8 +++-----
 2 files changed, 3 insertions(+), 5 deletions(-)
 rename dygma-layer-switcher/src/{images.rs => icon.rs} (100%)

diff --git a/dygma-layer-switcher/src/images.rs b/dygma-layer-switcher/src/icon.rs
similarity index 100%
rename from dygma-layer-switcher/src/images.rs
rename to dygma-layer-switcher/src/icon.rs
diff --git a/dygma-layer-switcher/src/main.rs b/dygma-layer-switcher/src/main.rs
index fe1b763..db8c0e1 100644
--- a/dygma-layer-switcher/src/main.rs
+++ b/dygma-layer-switcher/src/main.rs
@@ -11,7 +11,7 @@ use tray_icon::TrayIconBuilder;
 
 mod app;
 mod helpers;
-mod images;
+mod icon;
 mod layer;
 mod log;
 mod single;
@@ -25,12 +25,10 @@ pub const ICON: &[u8] = include_bytes!("../../assets/icons/icon.ico");
 pub fn main() -> Result<()> {
     single::check()?;
 
-    let icon = images::load_tray_icon(ICON)?;
+    let icon = icon::load_tray_icon(ICON)?;
     let mut _tray_icon = Rc::new(RefCell::new(None));
     let tray_rc = _tray_icon.clone();
 
-    egui::IconData::default();
-
     let tray_menu = Menu::new();
     tray_menu
         .append(&MenuItem::new("Quit", true, None))
@@ -44,7 +42,7 @@ pub fn main() -> Result<()> {
             persist_window: true,
             centered: false,
             vsync: true,
-            viewport: { ViewportBuilder::default().with_icon(Arc::new(images::load_icon(ICON))) },
+            viewport: ViewportBuilder::default().with_icon(Arc::new(icon::load_icon(ICON))),
             ..Default::default()
         },
         Box::new(move |cc| {

From b385a5fef36335d13ead4a3e4466617b65b618a6 Mon Sep 17 00:00:00 2001
From: Matthew Wilding <mbwilding@gmail.com>
Date: Sun, 17 Dec 2023 10:34:00 +0800
Subject: [PATCH 23/39] Fixed exclude remove panic

---
 dygma-layer-switcher/src/app.rs | 13 +++++++------
 dygma-layer-switcher/src/log.rs |  2 +-
 2 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/dygma-layer-switcher/src/app.rs b/dygma-layer-switcher/src/app.rs
index d1d3657..651feed 100644
--- a/dygma-layer-switcher/src/app.rs
+++ b/dygma-layer-switcher/src/app.rs
@@ -255,8 +255,11 @@ impl DygmaLayerSwitcher {
                                                 .id_source(format!("excludes_{}", index))
                                                 .default_open(true)
                                                 .show(ui, |ui| {
-                                                    parent.excludes.iter_mut().for_each(
-                                                        |exclude| {
+                                                    parent
+                                                        .excludes
+                                                        .iter_mut()
+                                                        .enumerate()
+                                                        .for_each(|(index, exclude)| {
                                                             ui.horizontal(|ui| {
                                                                 ui.checkbox(
                                                                     &mut exclude.is_enabled,
@@ -278,18 +281,16 @@ impl DygmaLayerSwitcher {
                                                                     &mut exclude.is_editing,
                                                                 );
                                                             });
-                                                        },
-                                                    );
+                                                        });
                                                     remove_opt_index(
                                                         &mut parent.excludes,
                                                         &mut self.remove_exclude,
-                                                    )
+                                                    );
                                                 });
                                         }
                                     }
                                 }
                             });
-
                         remove_opt_index(&mut layer.apps, &mut self.remove_app);
                     });
                 });
diff --git a/dygma-layer-switcher/src/log.rs b/dygma-layer-switcher/src/log.rs
index c16dec4..b110bb2 100644
--- a/dygma-layer-switcher/src/log.rs
+++ b/dygma-layer-switcher/src/log.rs
@@ -1,4 +1,4 @@
-use tracing_subscriber::filter::{EnvFilter, LevelFilter};
+use tracing_subscriber::filter::EnvFilter;
 use tracing_subscriber::fmt;
 use tracing_subscriber::prelude::*;
 

From d14f735801ac711ae4067f83126f1a344ab3fc99 Mon Sep 17 00:00:00 2001
From: Matthew Wilding <mbwilding@gmail.com>
Date: Sun, 17 Dec 2023 10:59:56 +0800
Subject: [PATCH 24/39] Fixed scrolling

---
 dygma-layer-switcher/src/app.rs | 262 +++++++++++++++++---------------
 1 file changed, 136 insertions(+), 126 deletions(-)

diff --git a/dygma-layer-switcher/src/app.rs b/dygma-layer-switcher/src/app.rs
index 651feed..9af463f 100644
--- a/dygma-layer-switcher/src/app.rs
+++ b/dygma-layer-switcher/src/app.rs
@@ -2,7 +2,9 @@ use crate::helpers::remove_opt_index;
 use crate::structs::*;
 use crate::templates::*;
 use dygma_focus::Focus;
-use eframe::egui::{CentralPanel, CollapsingHeader, Context, DragValue, TopBottomPanel};
+use eframe::egui::{
+    CentralPanel, CollapsingHeader, Context, DragValue, ScrollArea, TopBottomPanel,
+};
 use eframe::{egui, Frame, Storage};
 use serde::{Deserialize, Serialize};
 use std::collections::{BTreeMap, BTreeSet};
@@ -157,144 +159,152 @@ impl DygmaLayerSwitcher {
     fn central_panel(&mut self, ctx: &Context) {
         CentralPanel::default().show(ctx, |ui| {
             ui.label("Right click to rename the layer.");
-            for (index, layer) in self.mappings.iter_mut() {
-                if self.hidden_layers.contains(index) {
-                    continue;
-                }
-                ui.horizontal(|ui| {
-                    if ui.button("👁").clicked() {
-                        self.hidden_layers.insert(*index);
-                    }
-                    editable_collapsing(ui, &mut layer.name, &mut layer.is_editing, |ui| {
+            ScrollArea::new([true, true])
+                .drag_to_scroll(true)
+                .auto_shrink(false)
+                .show(ui, |ui| {
+                    for (index, layer) in self.mappings.iter_mut() {
+                        if self.hidden_layers.contains(index) {
+                            continue;
+                        }
                         ui.horizontal(|ui| {
-                            if ui.button("Add Window").clicked() {
-                                layer.apps.push(App::new_window());
-                            }
-                            if ui.button("Add Process").clicked() {
-                                layer.apps.push(App::new_process());
+                            if ui.button("👁").clicked() {
+                                self.hidden_layers.insert(*index);
                             }
-                            if ui.button("Add Parent").clicked() {
-                                layer.apps.push(App::new_parent());
-                            }
-                        });
-
-                        CollapsingHeader::new("Windows")
-                            .default_open(true)
-                            .show(ui, |ui| {
-                                for (index, app) in layer.apps.iter_mut().enumerate() {
-                                    if let Mode::Window(window) = &mut app.mode {
-                                        ui.horizontal(|ui| {
-                                            ui.checkbox(&mut app.is_enabled, "");
-                                            if ui
-                                                .button(" - ")
-                                                .on_hover_text("Remove this window.")
-                                                .clicked()
-                                            {
-                                                self.remove_app = Some(index);
-                                            }
-                                            editable_label(
-                                                ui,
-                                                &mut window.name,
-                                                &mut window.is_editing,
-                                            );
-                                        });
+                            editable_collapsing(ui, &mut layer.name, &mut layer.is_editing, |ui| {
+                                ui.horizontal(|ui| {
+                                    if ui.button("Add Window").clicked() {
+                                        layer.apps.push(App::new_window());
                                     }
-                                }
-                            });
-
-                        CollapsingHeader::new("Processes")
-                            .default_open(true)
-                            .show(ui, |ui| {
-                                for (index, app) in layer.apps.iter_mut().enumerate() {
-                                    if let Mode::Process(process) = &mut app.mode {
-                                        ui.horizontal(|ui| {
-                                            ui.checkbox(&mut app.is_enabled, "");
-                                            if ui
-                                                .button(" - ")
-                                                .on_hover_text("Remove this process.")
-                                                .clicked()
-                                            {
-                                                self.remove_app = Some(index);
-                                            }
-                                            editable_label(
-                                                ui,
-                                                &mut process.name,
-                                                &mut process.is_editing,
-                                            );
-                                        });
+                                    if ui.button("Add Process").clicked() {
+                                        layer.apps.push(App::new_process());
                                     }
-                                }
-                            });
+                                    if ui.button("Add Parent").clicked() {
+                                        layer.apps.push(App::new_parent());
+                                    }
+                                });
 
-                        CollapsingHeader::new("Parents")
-                            .default_open(true)
-                            .show(ui, |ui| {
-                                for (index, app) in layer.apps.iter_mut().enumerate() {
-                                    if let Mode::Parent(parent) = &mut app.mode {
-                                        ui.horizontal(|ui| {
-                                            ui.checkbox(&mut app.is_enabled, "");
-                                            if ui
-                                                .button(" - ")
-                                                .on_hover_text("Remove this parent.")
-                                                .clicked()
-                                            {
-                                                self.remove_app = Some(index);
+                                CollapsingHeader::new("Windows").default_open(true).show(
+                                    ui,
+                                    |ui| {
+                                        for (index, app) in layer.apps.iter_mut().enumerate() {
+                                            if let Mode::Window(window) = &mut app.mode {
+                                                ui.horizontal(|ui| {
+                                                    ui.checkbox(&mut app.is_enabled, "");
+                                                    if ui
+                                                        .button(" - ")
+                                                        .on_hover_text("Remove this window.")
+                                                        .clicked()
+                                                    {
+                                                        self.remove_app = Some(index);
+                                                    }
+                                                    editable_label(
+                                                        ui,
+                                                        &mut window.name,
+                                                        &mut window.is_editing,
+                                                    );
+                                                });
                                             }
-                                            if ui.button("Add Exclude").clicked() {
-                                                parent.excludes.push(Exclude::new());
+                                        }
+                                    },
+                                );
+
+                                CollapsingHeader::new("Processes").default_open(true).show(
+                                    ui,
+                                    |ui| {
+                                        for (index, app) in layer.apps.iter_mut().enumerate() {
+                                            if let Mode::Process(process) = &mut app.mode {
+                                                ui.horizontal(|ui| {
+                                                    ui.checkbox(&mut app.is_enabled, "");
+                                                    if ui
+                                                        .button(" - ")
+                                                        .on_hover_text("Remove this process.")
+                                                        .clicked()
+                                                    {
+                                                        self.remove_app = Some(index);
+                                                    }
+                                                    editable_label(
+                                                        ui,
+                                                        &mut process.name,
+                                                        &mut process.is_editing,
+                                                    );
+                                                });
                                             }
-                                            editable_label(
-                                                ui,
-                                                &mut parent.name,
-                                                &mut parent.is_editing,
-                                            );
-                                        });
+                                        }
+                                    },
+                                );
 
-                                        if !parent.excludes.is_empty() {
-                                            CollapsingHeader::new("Excludes")
-                                                .id_source(format!("excludes_{}", index))
-                                                .default_open(true)
-                                                .show(ui, |ui| {
-                                                    parent
-                                                        .excludes
-                                                        .iter_mut()
-                                                        .enumerate()
-                                                        .for_each(|(index, exclude)| {
-                                                            ui.horizontal(|ui| {
-                                                                ui.checkbox(
-                                                                    &mut exclude.is_enabled,
-                                                                    "",
-                                                                );
-                                                                if ui
-                                                                    .button(" - ")
-                                                                    .on_hover_text(
-                                                                        "Remove this exclude.",
-                                                                    )
-                                                                    .clicked()
-                                                                {
-                                                                    self.remove_exclude =
-                                                                        Some(index);
-                                                                }
-                                                                editable_label(
-                                                                    ui,
-                                                                    &mut exclude.name,
-                                                                    &mut exclude.is_editing,
-                                                                );
-                                                            });
-                                                        });
-                                                    remove_opt_index(
-                                                        &mut parent.excludes,
-                                                        &mut self.remove_exclude,
+                                CollapsingHeader::new("Parents").default_open(true).show(
+                                    ui,
+                                    |ui| {
+                                        for (index, app) in layer.apps.iter_mut().enumerate() {
+                                            if let Mode::Parent(parent) = &mut app.mode {
+                                                ui.horizontal(|ui| {
+                                                    ui.checkbox(&mut app.is_enabled, "");
+                                                    if ui
+                                                        .button(" - ")
+                                                        .on_hover_text("Remove this parent.")
+                                                        .clicked()
+                                                    {
+                                                        self.remove_app = Some(index);
+                                                    }
+                                                    if ui.button("Add Exclude").clicked() {
+                                                        parent.excludes.push(Exclude::new());
+                                                    }
+                                                    editable_label(
+                                                        ui,
+                                                        &mut parent.name,
+                                                        &mut parent.is_editing,
                                                     );
                                                 });
+
+                                                if !parent.excludes.is_empty() {
+                                                    CollapsingHeader::new("Excludes")
+                                                        .id_source(format!("excludes_{}", index))
+                                                        .default_open(true)
+                                                        .show(ui, |ui| {
+                                                            parent
+                                                                .excludes
+                                                                .iter_mut()
+                                                                .enumerate()
+                                                                .for_each(|(index, exclude)| {
+                                                                    ui.horizontal(|ui| {
+                                                                        ui.checkbox(
+                                                                            &mut exclude.is_enabled,
+                                                                            "",
+                                                                        );
+                                                                        if ui
+                                                                        .button(" - ")
+                                                                        .on_hover_text(
+                                                                            "Remove this exclude.",
+                                                                        )
+                                                                        .clicked()
+                                                                    {
+                                                                        self.remove_exclude =
+                                                                            Some(index);
+                                                                    }
+                                                                        editable_label(
+                                                                            ui,
+                                                                            &mut exclude.name,
+                                                                            &mut exclude.is_editing,
+                                                                        );
+                                                                    });
+                                                                });
+                                                            remove_opt_index(
+                                                                &mut parent.excludes,
+                                                                &mut self.remove_exclude,
+                                                            );
+                                                        });
+                                                }
+                                            }
                                         }
-                                    }
-                                }
+                                    },
+                                );
+                                remove_opt_index(&mut layer.apps, &mut self.remove_app);
                             });
-                        remove_opt_index(&mut layer.apps, &mut self.remove_app);
-                    });
+                        });
+                    }
                 });
-            }
         });
     }
 }

From 27a02a9e4b5ae5b2e755954383c5b94f8d9d8f3e Mon Sep 17 00:00:00 2001
From: Matthew Wilding <mbwilding@gmail.com>
Date: Sun, 17 Dec 2023 14:25:46 +0800
Subject: [PATCH 25/39] Moved rename hint.

---
 dygma-layer-switcher/src/app.rs       |  1 -
 dygma-layer-switcher/src/templates.rs | 11 ++++++++---
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/dygma-layer-switcher/src/app.rs b/dygma-layer-switcher/src/app.rs
index 9af463f..109f8ab 100644
--- a/dygma-layer-switcher/src/app.rs
+++ b/dygma-layer-switcher/src/app.rs
@@ -158,7 +158,6 @@ impl DygmaLayerSwitcher {
 
     fn central_panel(&mut self, ctx: &Context) {
         CentralPanel::default().show(ctx, |ui| {
-            ui.label("Right click to rename the layer.");
             ScrollArea::new([true, true])
                 .drag_to_scroll(true)
                 .auto_shrink(false)
diff --git a/dygma-layer-switcher/src/templates.rs b/dygma-layer-switcher/src/templates.rs
index 682a675..7df1dc5 100644
--- a/dygma-layer-switcher/src/templates.rs
+++ b/dygma-layer-switcher/src/templates.rs
@@ -1,4 +1,5 @@
 use eframe::egui;
+use eframe::egui::CollapsingHeader;
 
 pub fn editable_label(ui: &mut egui::Ui, value: &mut String, editing: &mut bool) {
     if *editing {
@@ -21,13 +22,17 @@ pub fn editable_collapsing<F: FnMut(&mut egui::Ui)>(
             *editing = false;
         }
     } else {
-        let header_response = ui
-            .collapsing(&value.clone(), |ui| {
+        let header_response = CollapsingHeader::new(value.clone())
+            .default_open(false)
+            .show(ui, |ui| {
                 content(ui);
             })
             .header_response;
 
-        if header_response.secondary_clicked() {
+        if header_response
+            .on_hover_text("Right click to rename.")
+            .secondary_clicked()
+        {
             *editing = true;
         }
     }

From 64c08a08619c7909f14e07a1ba0ce6c86f54e6c1 Mon Sep 17 00:00:00 2001
From: Matthew Wilding <mbwilding@gmail.com>
Date: Sun, 17 Dec 2023 15:36:10 +0800
Subject: [PATCH 26/39] Channel added

---
 .run/Debug.run.xml                  |  2 +-
 dygma-layer-switcher/Cargo.toml     |  2 ++
 dygma-layer-switcher/src/app.rs     | 16 +++++++++
 dygma-layer-switcher/src/layer.rs   | 55 +++++++++++++++--------------
 dygma-layer-switcher/src/log.rs     | 12 +++++--
 dygma-layer-switcher/src/main.rs    |  3 +-
 dygma-layer-switcher/src/windows.rs | 25 ++++++++-----
 7 files changed, 76 insertions(+), 39 deletions(-)

diff --git a/.run/Debug.run.xml b/.run/Debug.run.xml
index 8b34a94..9a1dc0f 100644
--- a/.run/Debug.run.xml
+++ b/.run/Debug.run.xml
@@ -1,6 +1,6 @@
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="Debug" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
-    <option name="command" value="run --bin dygma-layer-switcher --features no-admin" />
+    <option name="command" value="run --bin dygma-layer-switcher" />
     <option name="workingDirectory" value="file://$PROJECT_DIR$" />
     <option name="emulateTerminal" value="true" />
     <option name="channel" value="DEFAULT" />
diff --git a/dygma-layer-switcher/Cargo.toml b/dygma-layer-switcher/Cargo.toml
index fa67b52..8004dda 100644
--- a/dygma-layer-switcher/Cargo.toml
+++ b/dygma-layer-switcher/Cargo.toml
@@ -6,6 +6,7 @@ authors = ["Matthew Wilding <mbwilding@gmail.com>"]
 
 [dependencies]
 anyhow = "1.0"
+crossbeam-channel = "0.5"
 dygma_focus = { git = "https://github.com/mbwilding/dygma-focus-api-rs" }
 eframe = { version = "0.24", default-features = false, features = [
     "default_fonts",
@@ -13,6 +14,7 @@ eframe = { version = "0.24", default-features = false, features = [
     "persistence",
 ] }
 image = "0.24"
+lazy_static = "1.4.0"
 serde = { version = "1.0", features = ["derive"] }
 single-instance = "0.3"
 tracing = "0.1"
diff --git a/dygma-layer-switcher/src/app.rs b/dygma-layer-switcher/src/app.rs
index 109f8ab..67c467a 100644
--- a/dygma-layer-switcher/src/app.rs
+++ b/dygma-layer-switcher/src/app.rs
@@ -1,11 +1,14 @@
 use crate::helpers::remove_opt_index;
+use crate::layer;
 use crate::structs::*;
 use crate::templates::*;
+use crossbeam_channel::{Receiver, Sender};
 use dygma_focus::Focus;
 use eframe::egui::{
     CentralPanel, CollapsingHeader, Context, DragValue, ScrollArea, TopBottomPanel,
 };
 use eframe::{egui, Frame, Storage};
+use lazy_static::lazy_static;
 use serde::{Deserialize, Serialize};
 use std::collections::{BTreeMap, BTreeSet};
 use tracing::{error, trace, warn};
@@ -14,6 +17,11 @@ use tray_icon::{ClickType, TrayIconEvent};
 
 const MAX_LAYERS: u8 = 10;
 
+lazy_static! {
+    pub static ref CHANNELS: (Sender<AppDetails>, Receiver<AppDetails>) =
+        crossbeam_channel::unbounded::<AppDetails>();
+}
+
 #[derive(Deserialize, Serialize)]
 #[serde(default)]
 pub struct DygmaLayerSwitcher {
@@ -310,6 +318,12 @@ impl DygmaLayerSwitcher {
 
 impl eframe::App for DygmaLayerSwitcher {
     fn update(&mut self, ctx: &Context, _frame: &mut Frame) {
+        // Window focus
+        if let Ok(event) = CHANNELS.1.try_recv() {
+            layer::process(self, &event);
+        }
+
+        // Tray
         if let Ok(event) = TrayIconEvent::receiver().try_recv() {
             trace!("Tray icon event: {event:?}");
             match event.click_type {
@@ -330,6 +344,8 @@ impl eframe::App for DygmaLayerSwitcher {
                 ctx.send_viewport_cmd(egui::ViewportCommand::Close);
             }
         }
+
+        // UI
         self.top_panel(ctx);
         self.central_panel(ctx);
     }
diff --git a/dygma-layer-switcher/src/layer.rs b/dygma-layer-switcher/src/layer.rs
index f5391df..ef548fb 100644
--- a/dygma-layer-switcher/src/layer.rs
+++ b/dygma-layer-switcher/src/layer.rs
@@ -1,34 +1,37 @@
+use crate::app::DygmaLayerSwitcher;
 use crate::structs::AppDetails;
-use tracing::debug;
+use tracing::{error, info};
 
-pub fn process(app_details: &AppDetails) {
-    debug!("{:?}", app_details);
+pub fn process(config: &DygmaLayerSwitcher, app_details: &AppDetails) {
+    let layer = check_window(app_details)
+        .or_else(|| check_process(app_details))
+        .or_else(|| check_parent(app_details))
+        .unwrap_or(config.base_layer);
 
-    // TODO
-    // let config = Config::load();
+    layer_change(config, layer);
+}
+
+fn layer_change(config: &DygmaLayerSwitcher, layer: u8) {
+    let mut focus = dygma_focus::Focus::default();
+    if focus.open_via_port(&config.port).is_ok() {
+        if focus.layer_move_to(layer - 1).is_ok() {
+            info!("Changed layer: {}", layer);
+        } else {
+            error!("Failed to write to serial port: {:?}", &config.port);
+        }
+    } else {
+        error!("Failed to open serial port: {:?}", &config.port);
+    }
+}
 
-    // let layer = config
-    //     .check_window(app_details)
-    //     .or_else(|| config.check_process(app_details))
-    //     .or_else(|| config.check_parent(app_details))
-    //     .unwrap_or_else(|| config.base_layer.unwrap_or_default());
+fn check_window(app_details: &AppDetails) -> Option<u8> {
+    None
+}
 
-    // layer_change(&config, layer);
+fn check_process(app_details: &AppDetails) -> Option<u8> {
+    None
 }
 
-fn layer_change(layer: u8) {
-    // if let Some(port) = &config.comm_port {
-    //     let mut focus = dygma_focus::Focus::default();
-    //     if focus.open_via_port(port).is_ok() {
-    //         if focus.layer_move_to(layer - 1).is_ok() {
-    //             info!("Changed layer: {}", layer);
-    //         } else {
-    //             error!("Failed to write to serial port: {:?}", &config.comm_port);
-    //         }
-    //     } else {
-    //         error!("Failed to open serial port: {:?}", &config.comm_port);
-    //     }
-    // } else {
-    //     error!("No serial port specified");
-    // }
+fn check_parent(app_details: &AppDetails) -> Option<u8> {
+    None
 }
diff --git a/dygma-layer-switcher/src/log.rs b/dygma-layer-switcher/src/log.rs
index b110bb2..c03e8f5 100644
--- a/dygma-layer-switcher/src/log.rs
+++ b/dygma-layer-switcher/src/log.rs
@@ -3,7 +3,7 @@ use tracing_subscriber::fmt;
 use tracing_subscriber::prelude::*;
 
 pub fn init(logging: bool) {
-    let base_filter = EnvFilter::new("info")
+    let console_filter = EnvFilter::new("debug")
         .add_directive("dygma-layer-switcher=trace".parse().unwrap())
         .add_directive("egui=warn".parse().unwrap())
         .add_directive("wgpu=warn".parse().unwrap());
@@ -12,17 +12,23 @@ pub fn init(logging: bool) {
         .with_ansi(true)
         .without_time()
         .compact()
-        .with_filter(base_filter);
+        .with_filter(console_filter);
 
     let subscriber_builder = tracing_subscriber::registry();
 
     if logging {
+        let file_filter = EnvFilter::new("trace")
+            .add_directive("dygma-layer-switcher=trace".parse().unwrap())
+            .add_directive("egui=warn".parse().unwrap())
+            .add_directive("wgpu=warn".parse().unwrap());
+
         subscriber_builder
             .with(console_layer)
             .with(
                 fmt::layer()
                     .with_ansi(false)
-                    .with_writer(tracing_appender::rolling::daily("logs", "dsl")),
+                    .with_writer(tracing_appender::rolling::daily("logs", "dsl"))
+                    .with_filter(file_filter),
             )
             .init();
     } else {
diff --git a/dygma-layer-switcher/src/main.rs b/dygma-layer-switcher/src/main.rs
index db8c0e1..95eaa25 100644
--- a/dygma-layer-switcher/src/main.rs
+++ b/dygma-layer-switcher/src/main.rs
@@ -1,6 +1,7 @@
 // hide console window on Windows in release
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 
+use crate::app::DygmaLayerSwitcher;
 use anyhow::Result;
 use eframe::egui::ViewportBuilder;
 use eframe::*;
@@ -54,7 +55,7 @@ pub fn main() -> Result<()> {
                     .build()
                     .unwrap(),
             );
-            let app = app::DygmaLayerSwitcher::new(cc);
+            let app = DygmaLayerSwitcher::new(cc);
             log::init(app.logging);
             windows::start();
             Box::new(app)
diff --git a/dygma-layer-switcher/src/windows.rs b/dygma-layer-switcher/src/windows.rs
index 21572b9..ce7a820 100644
--- a/dygma-layer-switcher/src/windows.rs
+++ b/dygma-layer-switcher/src/windows.rs
@@ -3,7 +3,7 @@ use crate::structs::AppDetails;
 use std::path::Path;
 use std::sync::atomic::AtomicU32;
 use std::sync::atomic::Ordering;
-use tracing::{error, info, trace};
+use tracing::{debug, error, info, trace};
 use windows::core::PCWSTR;
 use windows::Win32::{
     Foundation::{HWND, MAX_PATH},
@@ -25,10 +25,14 @@ use windows::Win32::{
 ///
 /// WinAPI.
 pub unsafe fn hydrate(window_handle: HWND) -> AppDetails {
-    AppDetails {
+    let app_details = AppDetails {
         window: get_window(window_handle),
         process: get_process(window_handle),
-    }
+    };
+
+    debug!("{:?}", app_details);
+
+    app_details
 }
 
 /// # Safety
@@ -98,7 +102,7 @@ static DEBOUNCER: AtomicU32 = AtomicU32::new(0);
 /// # Safety
 ///
 /// WinAPI.
-pub unsafe extern "system" fn get_focused_window_details(
+pub unsafe extern "system" fn new_window_focused(
     _h_win_event_hook: HWINEVENTHOOK,
     _event: u32,
     window_handle: HWND,
@@ -120,13 +124,18 @@ pub unsafe extern "system" fn get_focused_window_details(
     DEBOUNCER.store(dwms_event_time, Ordering::SeqCst);
 
     let app_details = hydrate(window_handle);
-    layer::process(&app_details);
+    crate::app::CHANNELS
+        .0
+        .send(app_details)
+        .unwrap_or_else(|e| {
+            error!("Failed to send app details: {:?}", e);
+        });
 }
 
 pub fn start() {
     std::thread::spawn(|| {
         unsafe {
-            info!("Attempting Hook");
+            debug!("Hooking");
 
             let module_handle = GetModuleHandleW(PCWSTR::null()).unwrap_or_else(|e| {
                 error!("Failed to get module handle: {:?}", e);
@@ -137,13 +146,13 @@ pub fn start() {
                 EVENT_OBJECT_FOCUS,
                 EVENT_OBJECT_FOCUS,
                 module_handle,
-                Some(get_focused_window_details),
+                Some(new_window_focused),
                 0,
                 0,
                 WINEVENT_OUTOFCONTEXT,
             );
 
-            info!("Hooked");
+            debug!("Hooked");
 
             let mut msg = MSG::default();
 

From af8e996de896b818a70dbbbb367fad0f472b2c35 Mon Sep 17 00:00:00 2001
From: Matthew Wilding <mbwilding@gmail.com>
Date: Sun, 17 Dec 2023 15:51:22 +0800
Subject: [PATCH 27/39] Process and window

---
 dygma-layer-switcher/src/layer.rs | 34 ++++++++++++++++++++++++-------
 1 file changed, 27 insertions(+), 7 deletions(-)

diff --git a/dygma-layer-switcher/src/layer.rs b/dygma-layer-switcher/src/layer.rs
index ef548fb..e7eb86f 100644
--- a/dygma-layer-switcher/src/layer.rs
+++ b/dygma-layer-switcher/src/layer.rs
@@ -1,11 +1,11 @@
 use crate::app::DygmaLayerSwitcher;
-use crate::structs::AppDetails;
+use crate::structs::{AppDetails, Mode};
 use tracing::{error, info};
 
 pub fn process(config: &DygmaLayerSwitcher, app_details: &AppDetails) {
-    let layer = check_window(app_details)
-        .or_else(|| check_process(app_details))
-        .or_else(|| check_parent(app_details))
+    let layer = check_window(config, app_details)
+        .or_else(|| check_process(config, app_details))
+        .or_else(|| check_parent(config, app_details))
         .unwrap_or(config.base_layer);
 
     layer_change(config, layer);
@@ -24,14 +24,34 @@ fn layer_change(config: &DygmaLayerSwitcher, layer: u8) {
     }
 }
 
-fn check_window(app_details: &AppDetails) -> Option<u8> {
+fn check_window(config: &DygmaLayerSwitcher, app_details: &AppDetails) -> Option<u8> {
+    for (&layer_number, layer) in &config.mappings {
+        for app in &layer.apps {
+            if let Mode::Window(ref window) = app.mode {
+                if app.is_enabled && window.name == app_details.window {
+                    return Some(layer_number);
+                }
+            }
+        }
+    }
+
     None
 }
 
-fn check_process(app_details: &AppDetails) -> Option<u8> {
+fn check_process(config: &DygmaLayerSwitcher, app_details: &AppDetails) -> Option<u8> {
+    for (&layer_number, layer) in &config.mappings {
+        for app in &layer.apps {
+            if let Mode::Process(ref process) = app.mode {
+                if app.is_enabled && process.name == app_details.process {
+                    return Some(layer_number);
+                }
+            }
+        }
+    }
+
     None
 }
 
-fn check_parent(app_details: &AppDetails) -> Option<u8> {
+fn check_parent(config: &DygmaLayerSwitcher, app_details: &AppDetails) -> Option<u8> {
     None
 }

From af399655934e1ad15ae363d62872bccf078ad12f Mon Sep 17 00:00:00 2001
From: Matthew Wilding <mbwilding@gmail.com>
Date: Sun, 17 Dec 2023 16:14:48 +0800
Subject: [PATCH 28/39] Refac layer change

---
 dygma-layer-switcher/Cargo.toml   |  2 +-
 dygma-layer-switcher/src/layer.rs | 17 ++++++++++-------
 2 files changed, 11 insertions(+), 8 deletions(-)

diff --git a/dygma-layer-switcher/Cargo.toml b/dygma-layer-switcher/Cargo.toml
index 8004dda..eb9e8ed 100644
--- a/dygma-layer-switcher/Cargo.toml
+++ b/dygma-layer-switcher/Cargo.toml
@@ -14,7 +14,7 @@ eframe = { version = "0.24", default-features = false, features = [
     "persistence",
 ] }
 image = "0.24"
-lazy_static = "1.4.0"
+lazy_static = "1.4"
 serde = { version = "1.0", features = ["derive"] }
 single-instance = "0.3"
 tracing = "0.1"
diff --git a/dygma-layer-switcher/src/layer.rs b/dygma-layer-switcher/src/layer.rs
index e7eb86f..e7c3ef3 100644
--- a/dygma-layer-switcher/src/layer.rs
+++ b/dygma-layer-switcher/src/layer.rs
@@ -13,14 +13,17 @@ pub fn process(config: &DygmaLayerSwitcher, app_details: &AppDetails) {
 
 fn layer_change(config: &DygmaLayerSwitcher, layer: u8) {
     let mut focus = dygma_focus::Focus::default();
-    if focus.open_via_port(&config.port).is_ok() {
-        if focus.layer_move_to(layer - 1).is_ok() {
-            info!("Changed layer: {}", layer);
-        } else {
-            error!("Failed to write to serial port: {:?}", &config.port);
+    match focus.open_via_port(&config.port) {
+        Ok(_) => {
+            if let Err(e) = focus.layer_move_to(layer - 1) {
+                error!("Failed to write to serial port '{}': {:?}", &config.port, e);
+            } else {
+                info!("Changed layer: {}", layer);
+            }
+        }
+        Err(e) => {
+            error!("Failed to open serial port '{}': {:?}", &config.port, e);
         }
-    } else {
-        error!("Failed to open serial port: {:?}", &config.port);
     }
 }
 

From 45b3e704a52680cadf28fbd475a0064eb7aa458d Mon Sep 17 00:00:00 2001
From: Matthew Wilding <mbwilding@gmail.com>
Date: Sun, 17 Dec 2023 17:16:04 +0800
Subject: [PATCH 29/39] Fix for update while out of focus

---
 dygma-layer-switcher/src/app.rs | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/dygma-layer-switcher/src/app.rs b/dygma-layer-switcher/src/app.rs
index 67c467a..3947345 100644
--- a/dygma-layer-switcher/src/app.rs
+++ b/dygma-layer-switcher/src/app.rs
@@ -11,6 +11,9 @@ use eframe::{egui, Frame, Storage};
 use lazy_static::lazy_static;
 use serde::{Deserialize, Serialize};
 use std::collections::{BTreeMap, BTreeSet};
+use std::sync::{Arc, Mutex};
+use std::thread;
+use std::thread::Thread;
 use tracing::{error, trace, warn};
 use tray_icon::menu::MenuEvent;
 use tray_icon::{ClickType, TrayIconEvent};
@@ -22,7 +25,7 @@ lazy_static! {
         crossbeam_channel::unbounded::<AppDetails>();
 }
 
-#[derive(Deserialize, Serialize)]
+#[derive(Deserialize, Serialize, Clone)]
 #[serde(default)]
 pub struct DygmaLayerSwitcher {
     pub logging: bool,
@@ -318,9 +321,14 @@ impl DygmaLayerSwitcher {
 
 impl eframe::App for DygmaLayerSwitcher {
     fn update(&mut self, ctx: &Context, _frame: &mut Frame) {
+        // TODO: Temp fix to run loop while app is out of focus
+        ctx.request_repaint();
+
         // Window focus
         if let Ok(event) = CHANNELS.1.try_recv() {
-            layer::process(self, &event);
+            // let config = self.clone();
+            // thread::spawn(move || layer::process(&config, &event));
+            layer::process(self, &event)
         }
 
         // Tray

From 68722a4177f1bd21ce1c7c2ac45af2d482bb26d8 Mon Sep 17 00:00:00 2001
From: Matthew Wilding <mbwilding@gmail.com>
Date: Sun, 17 Dec 2023 17:18:49 +0800
Subject: [PATCH 30/39] Clippy and log change

---
 dygma-layer-switcher/src/app.rs     | 5 +----
 dygma-layer-switcher/src/layer.rs   | 2 +-
 dygma-layer-switcher/src/log.rs     | 2 ++
 dygma-layer-switcher/src/windows.rs | 3 +--
 4 files changed, 5 insertions(+), 7 deletions(-)

diff --git a/dygma-layer-switcher/src/app.rs b/dygma-layer-switcher/src/app.rs
index 3947345..d13c0c5 100644
--- a/dygma-layer-switcher/src/app.rs
+++ b/dygma-layer-switcher/src/app.rs
@@ -11,9 +11,6 @@ use eframe::{egui, Frame, Storage};
 use lazy_static::lazy_static;
 use serde::{Deserialize, Serialize};
 use std::collections::{BTreeMap, BTreeSet};
-use std::sync::{Arc, Mutex};
-use std::thread;
-use std::thread::Thread;
 use tracing::{error, trace, warn};
 use tray_icon::menu::MenuEvent;
 use tray_icon::{ClickType, TrayIconEvent};
@@ -346,7 +343,7 @@ impl eframe::App for DygmaLayerSwitcher {
             }
         }
         if let Ok(event) = MenuEvent::receiver().try_recv() {
-            trace!("Tray menu event: {event:?}");
+            trace!("Tray menu event: {:?}", event);
             // Exit
             if event.id == "1001" {
                 ctx.send_viewport_cmd(egui::ViewportCommand::Close);
diff --git a/dygma-layer-switcher/src/layer.rs b/dygma-layer-switcher/src/layer.rs
index e7c3ef3..19e79d2 100644
--- a/dygma-layer-switcher/src/layer.rs
+++ b/dygma-layer-switcher/src/layer.rs
@@ -55,6 +55,6 @@ fn check_process(config: &DygmaLayerSwitcher, app_details: &AppDetails) -> Optio
     None
 }
 
-fn check_parent(config: &DygmaLayerSwitcher, app_details: &AppDetails) -> Option<u8> {
+fn check_parent(_config: &DygmaLayerSwitcher, _app_details: &AppDetails) -> Option<u8> {
     None
 }
diff --git a/dygma-layer-switcher/src/log.rs b/dygma-layer-switcher/src/log.rs
index c03e8f5..094b7cd 100644
--- a/dygma-layer-switcher/src/log.rs
+++ b/dygma-layer-switcher/src/log.rs
@@ -6,6 +6,7 @@ pub fn init(logging: bool) {
     let console_filter = EnvFilter::new("debug")
         .add_directive("dygma-layer-switcher=trace".parse().unwrap())
         .add_directive("egui=warn".parse().unwrap())
+        .add_directive("eframe=warn".parse().unwrap())
         .add_directive("wgpu=warn".parse().unwrap());
 
     let console_layer = fmt::layer()
@@ -19,6 +20,7 @@ pub fn init(logging: bool) {
     if logging {
         let file_filter = EnvFilter::new("trace")
             .add_directive("dygma-layer-switcher=trace".parse().unwrap())
+            .add_directive("eframe=warn".parse().unwrap())
             .add_directive("egui=warn".parse().unwrap())
             .add_directive("wgpu=warn".parse().unwrap());
 
diff --git a/dygma-layer-switcher/src/windows.rs b/dygma-layer-switcher/src/windows.rs
index ce7a820..2d654b2 100644
--- a/dygma-layer-switcher/src/windows.rs
+++ b/dygma-layer-switcher/src/windows.rs
@@ -1,9 +1,8 @@
-use crate::layer;
 use crate::structs::AppDetails;
 use std::path::Path;
 use std::sync::atomic::AtomicU32;
 use std::sync::atomic::Ordering;
-use tracing::{debug, error, info, trace};
+use tracing::{debug, error, trace};
 use windows::core::PCWSTR;
 use windows::Win32::{
     Foundation::{HWND, MAX_PATH},

From 41ebd87f0b601325a98d21819c0f440d1af3eff5 Mon Sep 17 00:00:00 2001
From: Matthew Wilding <mbwilding@gmail.com>
Date: Sun, 17 Dec 2023 17:51:11 +0800
Subject: [PATCH 31/39] Fixed parent

---
 dygma-layer-switcher/Cargo.toml   |  1 +
 dygma-layer-switcher/src/app.rs   |  4 ++-
 dygma-layer-switcher/src/layer.rs | 42 ++++++++++++++++++++++++++++---
 3 files changed, 43 insertions(+), 4 deletions(-)

diff --git a/dygma-layer-switcher/Cargo.toml b/dygma-layer-switcher/Cargo.toml
index eb9e8ed..85984a9 100644
--- a/dygma-layer-switcher/Cargo.toml
+++ b/dygma-layer-switcher/Cargo.toml
@@ -17,6 +17,7 @@ image = "0.24"
 lazy_static = "1.4"
 serde = { version = "1.0", features = ["derive"] }
 single-instance = "0.3"
+sysinfo = "0.29"
 tracing = "0.1"
 tracing-appender = "0.2"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
diff --git a/dygma-layer-switcher/src/app.rs b/dygma-layer-switcher/src/app.rs
index d13c0c5..91502ac 100644
--- a/dygma-layer-switcher/src/app.rs
+++ b/dygma-layer-switcher/src/app.rs
@@ -139,7 +139,8 @@ impl DygmaLayerSwitcher {
                                 {
                                     self.remove_hidden_layer = Some(*layer);
                                 }
-                                ui.label(format!("{}: {}", layer + 1, &self.mappings[layer].name));
+                                ui.label(format!("{}", layer + 1));
+                                ui.label(self.mappings[layer].name.as_str());
                             });
                         }
                         if let Some(layer) = self.remove_hidden_layer {
@@ -178,6 +179,7 @@ impl DygmaLayerSwitcher {
                             if ui.button("👁").clicked() {
                                 self.hidden_layers.insert(*index);
                             }
+                            ui.label(format!("{}", index + 1));
                             editable_collapsing(ui, &mut layer.name, &mut layer.is_editing, |ui| {
                                 ui.horizontal(|ui| {
                                     if ui.button("Add Window").clicked() {
diff --git a/dygma-layer-switcher/src/layer.rs b/dygma-layer-switcher/src/layer.rs
index 19e79d2..bb21b54 100644
--- a/dygma-layer-switcher/src/layer.rs
+++ b/dygma-layer-switcher/src/layer.rs
@@ -1,12 +1,13 @@
 use crate::app::DygmaLayerSwitcher;
 use crate::structs::{AppDetails, Mode};
+use sysinfo::{ProcessExt, System, SystemExt};
 use tracing::{error, info};
 
 pub fn process(config: &DygmaLayerSwitcher, app_details: &AppDetails) {
     let layer = check_window(config, app_details)
         .or_else(|| check_process(config, app_details))
         .or_else(|| check_parent(config, app_details))
-        .unwrap_or(config.base_layer);
+        .unwrap_or(config.base_layer - 1);
 
     layer_change(config, layer);
 }
@@ -15,7 +16,7 @@ fn layer_change(config: &DygmaLayerSwitcher, layer: u8) {
     let mut focus = dygma_focus::Focus::default();
     match focus.open_via_port(&config.port) {
         Ok(_) => {
-            if let Err(e) = focus.layer_move_to(layer - 1) {
+            if let Err(e) = focus.layer_move_to(layer) {
                 error!("Failed to write to serial port '{}': {:?}", &config.port, e);
             } else {
                 info!("Changed layer: {}", layer);
@@ -55,6 +56,41 @@ fn check_process(config: &DygmaLayerSwitcher, app_details: &AppDetails) -> Optio
     None
 }
 
-fn check_parent(_config: &DygmaLayerSwitcher, _app_details: &AppDetails) -> Option<u8> {
+fn check_parent(config: &DygmaLayerSwitcher, app_details: &AppDetails) -> Option<u8> {
+    let mut sys = System::new_all();
+    sys.refresh_all();
+
+    // Find the specified process.
+    let specified_process = sys
+        .processes()
+        .values()
+        .find(|p| p.name() == app_details.process);
+
+    if let Some(proc) = specified_process {
+        // Check each parent process of the specified process.
+        let mut current_proc = Some(proc);
+        while let Some(proc) = current_proc {
+            for (&layer_number, layer) in &config.mappings {
+                for app in &layer.apps {
+                    if let Mode::Parent(ref parent) = app.mode {
+                        if app.is_enabled && parent.name == proc.name() {
+                            // Check if the process is disabled or is not excluded.
+                            let is_excluded = parent.excludes.iter().any(|exclude| {
+                                exclude.is_enabled && exclude.name == app_details.process
+                            });
+
+                            if !is_excluded {
+                                return Some(layer_number);
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Move to the parent process in the next iteration.
+            current_proc = proc.parent().and_then(|pid| sys.process(pid));
+        }
+    }
+
     None
 }

From 8680a49a846c2f9e91de810a821b579ac495e7b7 Mon Sep 17 00:00:00 2001
From: Matthew Wilding <mbwilding@gmail.com>
Date: Sun, 17 Dec 2023 17:52:59 +0800
Subject: [PATCH 32/39] Updated logging

---
 dygma-layer-switcher/src/layer.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dygma-layer-switcher/src/layer.rs b/dygma-layer-switcher/src/layer.rs
index bb21b54..115abc8 100644
--- a/dygma-layer-switcher/src/layer.rs
+++ b/dygma-layer-switcher/src/layer.rs
@@ -19,7 +19,7 @@ fn layer_change(config: &DygmaLayerSwitcher, layer: u8) {
             if let Err(e) = focus.layer_move_to(layer) {
                 error!("Failed to write to serial port '{}': {:?}", &config.port, e);
             } else {
-                info!("Changed layer: {}", layer);
+                info!("Changed layer: {}", config.mappings[&layer].name);
             }
         }
         Err(e) => {

From 87f527f03c1f11dc6de50c046494038970e11787 Mon Sep 17 00:00:00 2001
From: Matthew Wilding <mbwilding@gmail.com>
Date: Sun, 17 Dec 2023 17:54:46 +0800
Subject: [PATCH 33/39] Updated readme

---
 readme.md | 41 +----------------------------------------
 1 file changed, 1 insertion(+), 40 deletions(-)

diff --git a/readme.md b/readme.md
index 4526f2a..7998310 100644
--- a/readme.md
+++ b/readme.md
@@ -1,42 +1,3 @@
 # Dygma Layer Switcher
 
-## Config
-
-On the first run of `dygma-layer-switcher` the `config.yml` will be generated.
-
-```yaml
----
-# Toggle logging.
-logging: false
-
-# Port of the keyboard for RF and USB, can be seen when selecting the keyboard in bazecor.
-comm_port: "COM4"
-
-# Layer to return to when no matching window is found.
-base_layer: 1
-
-# The mappings, each mapping has a layer and a choice of `window`, `process`, and `parent`, ordered in respect to performance.
-# The settings aren't mutually exclusive nor are the layers.
-# All setting values are case-insensitive.
-
-# `window` is part of the title of the window.
-# `process` is part of the name of the process.
-# `parent` has a `process` and an optional `excludes` (array) section.
-
-# You can do any combination of the above, mix and match all you want under the layer's `app` section.
-mappings:
-  - layer: 4
-    apps:
-      - parent:
-          process: "EpicGamesLauncher.exe"
-      - parent:
-          process: "steam.exe"
-          excludes:
-            - "steamwebhelper.exe"
-            - "blender.exe"
-  - layer: 5
-    apps:
-      - window: "Autodesk MAYA"
-      - process: "blender.exe"
-
-```
+[Download here](https://github.com/mbwilding/dygma-layer-switcher/releases)

From 8d5596b0c44d08027cc4807bda1f427ab8fca363 Mon Sep 17 00:00:00 2001
From: Matthew Wilding <mbwilding@gmail.com>
Date: Sun, 17 Dec 2023 17:57:56 +0800
Subject: [PATCH 34/39] Updated CI

---
 .github/workflows/Release-Windows.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/Release-Windows.yml b/.github/workflows/Release-Windows.yml
index 0879d5d..925701f 100644
--- a/.github/workflows/Release-Windows.yml
+++ b/.github/workflows/Release-Windows.yml
@@ -31,10 +31,10 @@ jobs:
       - name: "Zip"
         run: |
           cp target/${{ matrix.target }}/release/dygma-layer-switcher.exe .
-          zip windows-${{ github.ref_name }}-${{ matrix.target }}.zip readme.md dygma-layer-switcher.exe
+          zip dls-${{ github.ref_name }}-${{ matrix.target }}.zip dygma-layer-switcher.exe
 
       - name: "Release"
         uses: softprops/action-gh-release@v1
         with:
           files: |
-            windows-${{ github.ref_name }}-${{ matrix.target }}.zip
+            dls-${{ github.ref_name }}-${{ matrix.target }}.zip

From 5fbb220ff12aa4b637b89d7594f226959ff523d4 Mon Sep 17 00:00:00 2001
From: Matthew Wilding <mbwilding@gmail.com>
Date: Sun, 17 Dec 2023 20:30:31 +0800
Subject: [PATCH 35/39] Fixed matching

---
 dygma-layer-switcher/src/app.rs   | 11 ++++++++++-
 dygma-layer-switcher/src/layer.rs | 11 +++++++++--
 dygma-layer-switcher/src/main.rs  |  7 +++++--
 3 files changed, 24 insertions(+), 5 deletions(-)

diff --git a/dygma-layer-switcher/src/app.rs b/dygma-layer-switcher/src/app.rs
index 91502ac..7dc7d4c 100644
--- a/dygma-layer-switcher/src/app.rs
+++ b/dygma-layer-switcher/src/app.rs
@@ -5,7 +5,7 @@ use crate::templates::*;
 use crossbeam_channel::{Receiver, Sender};
 use dygma_focus::Focus;
 use eframe::egui::{
-    CentralPanel, CollapsingHeader, Context, DragValue, ScrollArea, TopBottomPanel,
+    Align, CentralPanel, CollapsingHeader, Context, DragValue, Layout, ScrollArea, TopBottomPanel,
 };
 use eframe::{egui, Frame, Storage};
 use lazy_static::lazy_static;
@@ -154,6 +154,15 @@ impl DygmaLayerSwitcher {
 
     fn top_panel(&mut self, ctx: &Context) {
         TopBottomPanel::top("top_panel").show(ctx, |ui| {
+            ui.with_layout(Layout::right_to_left(Align::Min), |ui| {
+                ui.horizontal(|ui| {
+                    ui.button("Tray")
+                        .on_hover_text("Minimize to the system tray.")
+                        .clicked()
+                        .then(|| self.window_visible = !self.window_visible);
+                });
+            });
+            ui.separator();
             CollapsingHeader::new("Settings")
                 .default_open(true)
                 .show(ui, |ui| {
diff --git a/dygma-layer-switcher/src/layer.rs b/dygma-layer-switcher/src/layer.rs
index 115abc8..96c945e 100644
--- a/dygma-layer-switcher/src/layer.rs
+++ b/dygma-layer-switcher/src/layer.rs
@@ -32,7 +32,12 @@ fn check_window(config: &DygmaLayerSwitcher, app_details: &AppDetails) -> Option
     for (&layer_number, layer) in &config.mappings {
         for app in &layer.apps {
             if let Mode::Window(ref window) = app.mode {
-                if app.is_enabled && window.name == app_details.window {
+                if app.is_enabled
+                    && window
+                        .name
+                        .to_lowercase()
+                        .contains(&app_details.window.to_lowercase())
+                {
                     return Some(layer_number);
                 }
             }
@@ -46,7 +51,9 @@ fn check_process(config: &DygmaLayerSwitcher, app_details: &AppDetails) -> Optio
     for (&layer_number, layer) in &config.mappings {
         for app in &layer.apps {
             if let Mode::Process(ref process) = app.mode {
-                if app.is_enabled && process.name == app_details.process {
+                if app.is_enabled
+                    && process.name.to_lowercase() == app_details.process.to_lowercase()
+                {
                     return Some(layer_number);
                 }
             }
diff --git a/dygma-layer-switcher/src/main.rs b/dygma-layer-switcher/src/main.rs
index 95eaa25..3e0183f 100644
--- a/dygma-layer-switcher/src/main.rs
+++ b/dygma-layer-switcher/src/main.rs
@@ -39,11 +39,14 @@ pub fn main() -> Result<()> {
         "Dygma Layer Switcher",
         NativeOptions {
             default_theme: Theme::Dark,
-            follow_system_theme: true,
+            // follow_system_theme: true,
             persist_window: true,
             centered: false,
             vsync: true,
-            viewport: ViewportBuilder::default().with_icon(Arc::new(icon::load_icon(ICON))),
+            viewport: ViewportBuilder::default()
+                .with_minimize_button(false)
+                .with_maximize_button(false)
+                .with_icon(Arc::new(icon::load_icon(ICON))),
             ..Default::default()
         },
         Box::new(move |cc| {

From 0d05ad009f5112d3e3f635bb39cd9a4f3b3e2863 Mon Sep 17 00:00:00 2001
From: Matthew Wilding <mbwilding@gmail.com>
Date: Sun, 17 Dec 2023 21:45:23 +0800
Subject: [PATCH 36/39] Verbiage, precursor to multi language support

---
 dygma-layer-switcher/src/app.rs      | 124 ++++++++++++++++-----------
 dygma-layer-switcher/src/main.rs     |   6 +-
 dygma-layer-switcher/src/single.rs   |   4 +-
 dygma-layer-switcher/src/verbiage.rs |  33 +++++++
 4 files changed, 111 insertions(+), 56 deletions(-)
 create mode 100644 dygma-layer-switcher/src/verbiage.rs

diff --git a/dygma-layer-switcher/src/app.rs b/dygma-layer-switcher/src/app.rs
index 7dc7d4c..41eeb24 100644
--- a/dygma-layer-switcher/src/app.rs
+++ b/dygma-layer-switcher/src/app.rs
@@ -1,7 +1,7 @@
 use crate::helpers::remove_opt_index;
-use crate::layer;
 use crate::structs::*;
 use crate::templates::*;
+use crate::{layer, verbiage};
 use crossbeam_channel::{Receiver, Sender};
 use dygma_focus::Focus;
 use eframe::egui::{
@@ -50,11 +50,8 @@ pub struct DygmaLayerSwitcher {
 impl Default for DygmaLayerSwitcher {
     fn default() -> Self {
         let focus = Focus::default();
-        let port = focus.find_first().unwrap_or_else(|e| {
-            error!(
-                "Connect a Dygma keyboard and restart the application: {:?}",
-                e
-            );
+        let port = focus.find_first().unwrap_or_else(|_| {
+            error!("{}", verbiage::NO_KEYBOARD_MESSAGE);
             std::process::exit(1);
         });
 
@@ -90,25 +87,25 @@ impl DygmaLayerSwitcher {
 
     fn logging_control(&mut self, ui: &mut egui::Ui) {
         ui.horizontal(|ui| {
-            ui.label("Logging")
-                .on_hover_text("Enables logging to file.");
+            ui.label(verbiage::LOGGING_SETTING_HEADING)
+                .on_hover_text(verbiage::LOGGING_SETTING_HINT);
             ui.checkbox(&mut self.logging, "");
         });
     }
 
     fn port_control(&mut self, ui: &mut egui::Ui) {
         ui.horizontal(|ui| {
-            ui.label("Port")
-                .on_hover_text("The serial port to communicate with.");
+            ui.label(verbiage::PORT_SETTING_HEADING)
+                .on_hover_text(verbiage::PORT_SETTING_HINT);
             if ui
-                .button("↻")
-                .on_hover_text("Rescan for the communication port.")
+                .button(verbiage::PORT_SETTING_REFRESH_HEADING)
+                .on_hover_text(verbiage::PORT_SETTING_REFRESH_HINT)
                 .clicked()
             {
                 let focus = Focus::default();
                 match focus.find_first() {
                     Ok(port) => self.port = port.port,
-                    Err(e) => warn!("No Dygma keyboard detected: {:?}", e),
+                    Err(_) => warn!("{}", verbiage::NO_KEYBOARD_MESSAGE),
                 }
             };
             editable_label(ui, &mut self.port, &mut self.editing_port);
@@ -117,24 +114,28 @@ impl DygmaLayerSwitcher {
 
     fn base_layer_control(&mut self, ui: &mut egui::Ui) {
         ui.horizontal(|ui| {
-            ui.label("Base Layer")
-                .on_hover_text("The layer to return to.");
+            ui.label(verbiage::BASE_LAYER_SETTING_HEADING)
+                .on_hover_text(verbiage::BASE_LAYER_SETTING_HINT);
             ui.add(DragValue::new(&mut self.base_layer).clamp_range(1..=MAX_LAYERS))
-                .on_hover_text("Click and drag to change the base layer.");
+                .on_hover_text(verbiage::BASE_LAYER_VALUE_HINT);
         });
     }
 
     fn hidden_layer_control(&mut self, ui: &mut egui::Ui) {
         ui.horizontal(|ui| {
             if !self.hidden_layers.is_empty() {
-                CollapsingHeader::new("Hidden Layers")
+                CollapsingHeader::new(verbiage::HIDDEN_LAYERS_HEADING)
                     .default_open(false)
                     .show(ui, |ui| {
                         for layer in self.hidden_layers.iter() {
                             ui.horizontal(|ui| {
                                 if ui
-                                    .button(" - ")
-                                    .on_hover_text(format!("Unhide layer {}.", layer + 1))
+                                    .button(verbiage::BUTTON_REMOVE)
+                                    .on_hover_text(format!(
+                                        "{} {}.",
+                                        verbiage::HIDDEN_LAYERS_UNHIDE_HINT,
+                                        layer + 1
+                                    ))
                                     .clicked()
                                 {
                                     self.remove_hidden_layer = Some(*layer);
@@ -156,14 +157,14 @@ impl DygmaLayerSwitcher {
         TopBottomPanel::top("top_panel").show(ctx, |ui| {
             ui.with_layout(Layout::right_to_left(Align::Min), |ui| {
                 ui.horizontal(|ui| {
-                    ui.button("Tray")
-                        .on_hover_text("Minimize to the system tray.")
+                    ui.button(verbiage::MENU_TRAY_HEADING)
+                        .on_hover_text(verbiage::MENU_TRAY_HINT)
                         .clicked()
                         .then(|| self.window_visible = !self.window_visible);
                 });
             });
             ui.separator();
-            CollapsingHeader::new("Settings")
+            CollapsingHeader::new(verbiage::SETTINGS_HEADING)
                 .default_open(true)
                 .show(ui, |ui| {
                     self.logging_control(ui);
@@ -191,27 +192,39 @@ impl DygmaLayerSwitcher {
                             ui.label(format!("{}", index + 1));
                             editable_collapsing(ui, &mut layer.name, &mut layer.is_editing, |ui| {
                                 ui.horizontal(|ui| {
-                                    if ui.button("Add Window").clicked() {
+                                    if ui
+                                        .button(verbiage::BUTTON_ADD_WINDOW)
+                                        .on_hover_text(verbiage::WINDOW)
+                                        .clicked()
+                                    {
                                         layer.apps.push(App::new_window());
                                     }
-                                    if ui.button("Add Process").clicked() {
+                                    if ui
+                                        .button(verbiage::BUTTON_ADD_PROCESS)
+                                        .on_hover_text(verbiage::PROCESS)
+                                        .clicked()
+                                    {
                                         layer.apps.push(App::new_process());
                                     }
-                                    if ui.button("Add Parent").clicked() {
+                                    if ui
+                                        .button(verbiage::BUTTON_ADD_PARENT)
+                                        .on_hover_text(verbiage::PARENT)
+                                        .clicked()
+                                    {
                                         layer.apps.push(App::new_parent());
                                     }
                                 });
 
-                                CollapsingHeader::new("Windows").default_open(true).show(
-                                    ui,
-                                    |ui| {
+                                CollapsingHeader::new(verbiage::MODE_WINDOWS_HEADING)
+                                    .default_open(true)
+                                    .show(ui, |ui| {
                                         for (index, app) in layer.apps.iter_mut().enumerate() {
                                             if let Mode::Window(window) = &mut app.mode {
                                                 ui.horizontal(|ui| {
                                                     ui.checkbox(&mut app.is_enabled, "");
                                                     if ui
-                                                        .button(" - ")
-                                                        .on_hover_text("Remove this window.")
+                                                        .button(verbiage::BUTTON_REMOVE)
+                                                        .on_hover_text(verbiage::MODE_WINDOWS_HINT)
                                                         .clicked()
                                                     {
                                                         self.remove_app = Some(index);
@@ -224,19 +237,20 @@ impl DygmaLayerSwitcher {
                                                 });
                                             }
                                         }
-                                    },
-                                );
+                                    })
+                                    .header_response
+                                    .on_hover_text(verbiage::WINDOW);
 
-                                CollapsingHeader::new("Processes").default_open(true).show(
-                                    ui,
-                                    |ui| {
+                                CollapsingHeader::new(verbiage::MODE_PROCESSES_HEADING)
+                                    .default_open(true)
+                                    .show(ui, |ui| {
                                         for (index, app) in layer.apps.iter_mut().enumerate() {
                                             if let Mode::Process(process) = &mut app.mode {
                                                 ui.horizontal(|ui| {
                                                     ui.checkbox(&mut app.is_enabled, "");
                                                     if ui
-                                                        .button(" - ")
-                                                        .on_hover_text("Remove this process.")
+                                                        .button(verbiage::BUTTON_REMOVE)
+                                                        .on_hover_text(verbiage::MODE_PROCESSES_HINT)
                                                         .clicked()
                                                     {
                                                         self.remove_app = Some(index);
@@ -249,24 +263,29 @@ impl DygmaLayerSwitcher {
                                                 });
                                             }
                                         }
-                                    },
-                                );
+                                    })
+                                    .header_response
+                                    .on_hover_text(verbiage::PROCESS);
 
-                                CollapsingHeader::new("Parents").default_open(true).show(
-                                    ui,
-                                    |ui| {
+                                CollapsingHeader::new(verbiage::MODE_PARENT_HEADING)
+                                    .default_open(true)
+                                    .show(ui, |ui| {
                                         for (index, app) in layer.apps.iter_mut().enumerate() {
                                             if let Mode::Parent(parent) = &mut app.mode {
                                                 ui.horizontal(|ui| {
                                                     ui.checkbox(&mut app.is_enabled, "");
                                                     if ui
-                                                        .button(" - ")
-                                                        .on_hover_text("Remove this parent.")
+                                                        .button(verbiage::BUTTON_REMOVE)
+                                                        .on_hover_text(verbiage::MODE_PARENT_HINT)
                                                         .clicked()
                                                     {
                                                         self.remove_app = Some(index);
                                                     }
-                                                    if ui.button("Add Exclude").clicked() {
+                                                    if ui
+                                                        .button(verbiage::BUTTON_ADD_EXCLUDE)
+                                                        .on_hover_text(verbiage::EXCLUDES_HINT)
+                                                        .clicked()
+                                                    {
                                                         parent.excludes.push(Exclude::new());
                                                     }
                                                     editable_label(
@@ -277,7 +296,7 @@ impl DygmaLayerSwitcher {
                                                 });
 
                                                 if !parent.excludes.is_empty() {
-                                                    CollapsingHeader::new("Excludes")
+                                                    CollapsingHeader::new(verbiage::MODE_PARENT_EXCLUDES_HEADING)
                                                         .id_source(format!("excludes_{}", index))
                                                         .default_open(true)
                                                         .show(ui, |ui| {
@@ -292,9 +311,9 @@ impl DygmaLayerSwitcher {
                                                                             "",
                                                                         );
                                                                         if ui
-                                                                        .button(" - ")
+                                                                        .button(verbiage::BUTTON_REMOVE)
                                                                         .on_hover_text(
-                                                                            "Remove this exclude.",
+                                                                            verbiage::MODE_PARENT_EXCLUDES_HINT,
                                                                         )
                                                                         .clicked()
                                                                     {
@@ -312,12 +331,15 @@ impl DygmaLayerSwitcher {
                                                                 &mut parent.excludes,
                                                                 &mut self.remove_exclude,
                                                             );
-                                                        });
+                                                        })
+                                                        .header_response
+                                                        .on_hover_text(verbiage::EXCLUDES_HINT);
                                                 }
                                             }
                                         }
-                                    },
-                                );
+                                    })
+                                    .header_response
+                                    .on_hover_text(verbiage::PARENT);
                                 remove_opt_index(&mut layer.apps, &mut self.remove_app);
                             });
                         });
diff --git a/dygma-layer-switcher/src/main.rs b/dygma-layer-switcher/src/main.rs
index 3e0183f..c1d7e48 100644
--- a/dygma-layer-switcher/src/main.rs
+++ b/dygma-layer-switcher/src/main.rs
@@ -18,9 +18,9 @@ mod log;
 mod single;
 mod structs;
 mod templates;
+mod verbiage;
 mod windows;
 
-pub const TITLE: &str = "Dygma Layer Switcher";
 pub const ICON: &[u8] = include_bytes!("../../assets/icons/icon.ico");
 
 pub fn main() -> Result<()> {
@@ -36,7 +36,7 @@ pub fn main() -> Result<()> {
         .expect("Failed to append menu item");
 
     run_native(
-        "Dygma Layer Switcher",
+        verbiage::APP_NAME,
         NativeOptions {
             default_theme: Theme::Dark,
             // follow_system_theme: true,
@@ -53,7 +53,7 @@ pub fn main() -> Result<()> {
             tray_rc.borrow_mut().replace(
                 TrayIconBuilder::new()
                     .with_menu(Box::new(tray_menu))
-                    .with_tooltip(TITLE)
+                    .with_tooltip(verbiage::APP_NAME)
                     .with_icon(icon)
                     .build()
                     .unwrap(),
diff --git a/dygma-layer-switcher/src/single.rs b/dygma-layer-switcher/src/single.rs
index e344a55..ad8ad7a 100644
--- a/dygma-layer-switcher/src/single.rs
+++ b/dygma-layer-switcher/src/single.rs
@@ -1,10 +1,10 @@
-use crate::TITLE;
+use crate::verbiage;
 use anyhow::Result;
 use single_instance::SingleInstance;
 use tracing::error;
 
 pub fn check() -> Result<()> {
-    let instance = SingleInstance::new(TITLE)?;
+    let instance = SingleInstance::new(verbiage::APP_NAME)?;
 
     if !instance.is_single() {
         error!("Another instance of Dygma Layer Switcher is already running");
diff --git a/dygma-layer-switcher/src/verbiage.rs b/dygma-layer-switcher/src/verbiage.rs
new file mode 100644
index 0000000..9fff901
--- /dev/null
+++ b/dygma-layer-switcher/src/verbiage.rs
@@ -0,0 +1,33 @@
+pub const NO_KEYBOARD_MESSAGE: &str = "Connect a Dygma keyboard and restart the application.";
+pub const APP_NAME: &str = "Dygma Layer Switcher";
+pub const MENU_TRAY_HEADING: &str = "Tray";
+pub const MENU_TRAY_HINT: &str = "Minimize to the system tray.";
+pub const SETTINGS_HEADING: &str = "Settings";
+pub const BUTTON_ADD_WINDOW: &str = "Add window";
+pub const BUTTON_ADD_PROCESS: &str = "Add process";
+pub const BUTTON_ADD_PARENT: &str = "Add parent";
+pub const BUTTON_ADD_EXCLUDE: &str = "Add exclude";
+pub const MODE_WINDOWS_HEADING: &str = "Windows";
+pub const MODE_WINDOWS_HINT: &str = "Remove this window.";
+pub const MODE_PROCESSES_HEADING: &str = "Processes";
+pub const MODE_PROCESSES_HINT: &str = "Remove this process.";
+pub const MODE_PARENT_HEADING: &str = "Parents";
+pub const MODE_PARENT_HINT: &str = "Remove this parent.";
+pub const MODE_PARENT_EXCLUDES_HEADING: &str = "Excludes";
+pub const MODE_PARENT_EXCLUDES_HINT: &str = "Remove this exclude.";
+pub const LOGGING_SETTING_HEADING: &str = "Logging";
+pub const LOGGING_SETTING_HINT: &str = "Enables logging to file.";
+pub const PORT_SETTING_HEADING: &str = "Port";
+pub const PORT_SETTING_HINT: &str = "The serial port to communicate with.";
+pub const PORT_SETTING_REFRESH_HEADING: &str = "↻";
+pub const PORT_SETTING_REFRESH_HINT: &str = "Rescan for the communication port.";
+pub const BASE_LAYER_SETTING_HEADING: &str = "Base Layer";
+pub const BASE_LAYER_SETTING_HINT: &str = "The layer to return to.";
+pub const BASE_LAYER_VALUE_HINT: &str = "Click and drag to change the base layer.";
+pub const HIDDEN_LAYERS_HEADING: &str = "Hidden Layers";
+pub const HIDDEN_LAYERS_UNHIDE_HINT: &str = "Unhide layer";
+pub const BUTTON_REMOVE: &str = " - ";
+pub const WINDOW: &str = "Partial match of window title.";
+pub const PROCESS: &str = "The executable name including extension.";
+pub const PARENT: &str = "The parent executable name, and optional excludes of child processes.";
+pub const EXCLUDES_HINT: &str = "Exclude a child process.";

From ef5f5486d873eb565b5c0de832a5c4d36ea03890 Mon Sep 17 00:00:00 2001
From: Matthew Wilding <mbwilding@gmail.com>
Date: Sun, 17 Dec 2023 22:06:58 +0800
Subject: [PATCH 37/39] Almost ready

---
 dygma-layer-switcher/src/app.rs       | 11 +----------
 dygma-layer-switcher/src/main.rs      |  7 +++++--
 dygma-layer-switcher/src/templates.rs |  3 ++-
 dygma-layer-switcher/src/verbiage.rs  |  3 +--
 4 files changed, 9 insertions(+), 15 deletions(-)

diff --git a/dygma-layer-switcher/src/app.rs b/dygma-layer-switcher/src/app.rs
index 41eeb24..a7a0cfd 100644
--- a/dygma-layer-switcher/src/app.rs
+++ b/dygma-layer-switcher/src/app.rs
@@ -5,7 +5,7 @@ use crate::{layer, verbiage};
 use crossbeam_channel::{Receiver, Sender};
 use dygma_focus::Focus;
 use eframe::egui::{
-    Align, CentralPanel, CollapsingHeader, Context, DragValue, Layout, ScrollArea, TopBottomPanel,
+    CentralPanel, CollapsingHeader, Context, DragValue, ScrollArea, TopBottomPanel,
 };
 use eframe::{egui, Frame, Storage};
 use lazy_static::lazy_static;
@@ -155,15 +155,6 @@ impl DygmaLayerSwitcher {
 
     fn top_panel(&mut self, ctx: &Context) {
         TopBottomPanel::top("top_panel").show(ctx, |ui| {
-            ui.with_layout(Layout::right_to_left(Align::Min), |ui| {
-                ui.horizontal(|ui| {
-                    ui.button(verbiage::MENU_TRAY_HEADING)
-                        .on_hover_text(verbiage::MENU_TRAY_HINT)
-                        .clicked()
-                        .then(|| self.window_visible = !self.window_visible);
-                });
-            });
-            ui.separator();
             CollapsingHeader::new(verbiage::SETTINGS_HEADING)
                 .default_open(true)
                 .show(ui, |ui| {
diff --git a/dygma-layer-switcher/src/main.rs b/dygma-layer-switcher/src/main.rs
index c1d7e48..c61f32a 100644
--- a/dygma-layer-switcher/src/main.rs
+++ b/dygma-layer-switcher/src/main.rs
@@ -44,8 +44,11 @@ pub fn main() -> Result<()> {
             centered: false,
             vsync: true,
             viewport: ViewportBuilder::default()
-                .with_minimize_button(false)
-                .with_maximize_button(false)
+                .with_inner_size((400.0, 320.0))
+                .with_resizable(true)
+                .with_close_button(true)
+                .with_minimize_button(true)
+                .with_maximize_button(true)
                 .with_icon(Arc::new(icon::load_icon(ICON))),
             ..Default::default()
         },
diff --git a/dygma-layer-switcher/src/templates.rs b/dygma-layer-switcher/src/templates.rs
index 7df1dc5..c56fe98 100644
--- a/dygma-layer-switcher/src/templates.rs
+++ b/dygma-layer-switcher/src/templates.rs
@@ -1,3 +1,4 @@
+use crate::verbiage;
 use eframe::egui;
 use eframe::egui::CollapsingHeader;
 
@@ -30,7 +31,7 @@ pub fn editable_collapsing<F: FnMut(&mut egui::Ui)>(
             .header_response;
 
         if header_response
-            .on_hover_text("Right click to rename.")
+            .on_hover_text(verbiage::RENAME_HINT)
             .secondary_clicked()
         {
             *editing = true;
diff --git a/dygma-layer-switcher/src/verbiage.rs b/dygma-layer-switcher/src/verbiage.rs
index 9fff901..2923438 100644
--- a/dygma-layer-switcher/src/verbiage.rs
+++ b/dygma-layer-switcher/src/verbiage.rs
@@ -1,7 +1,5 @@
 pub const NO_KEYBOARD_MESSAGE: &str = "Connect a Dygma keyboard and restart the application.";
 pub const APP_NAME: &str = "Dygma Layer Switcher";
-pub const MENU_TRAY_HEADING: &str = "Tray";
-pub const MENU_TRAY_HINT: &str = "Minimize to the system tray.";
 pub const SETTINGS_HEADING: &str = "Settings";
 pub const BUTTON_ADD_WINDOW: &str = "Add window";
 pub const BUTTON_ADD_PROCESS: &str = "Add process";
@@ -31,3 +29,4 @@ pub const WINDOW: &str = "Partial match of window title.";
 pub const PROCESS: &str = "The executable name including extension.";
 pub const PARENT: &str = "The parent executable name, and optional excludes of child processes.";
 pub const EXCLUDES_HINT: &str = "Exclude a child process.";
+pub const RENAME_HINT: &str = "Right click to rename.";

From 9771a88a9499741e5830c3d844661d6c26266762 Mon Sep 17 00:00:00 2001
From: Matthew Wilding <mbwilding@gmail.com>
Date: Sun, 17 Dec 2023 22:07:48 +0800
Subject: [PATCH 38/39] More verbiage

---
 dygma-layer-switcher/src/main.rs     | 4 ++--
 dygma-layer-switcher/src/verbiage.rs | 1 +
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/dygma-layer-switcher/src/main.rs b/dygma-layer-switcher/src/main.rs
index c61f32a..86603bf 100644
--- a/dygma-layer-switcher/src/main.rs
+++ b/dygma-layer-switcher/src/main.rs
@@ -32,8 +32,8 @@ pub fn main() -> Result<()> {
 
     let tray_menu = Menu::new();
     tray_menu
-        .append(&MenuItem::new("Quit", true, None))
-        .expect("Failed to append menu item");
+        .append(&MenuItem::new(verbiage::TRAY_QUIT, true, None))
+        .unwrap();
 
     run_native(
         verbiage::APP_NAME,
diff --git a/dygma-layer-switcher/src/verbiage.rs b/dygma-layer-switcher/src/verbiage.rs
index 2923438..dc6fe50 100644
--- a/dygma-layer-switcher/src/verbiage.rs
+++ b/dygma-layer-switcher/src/verbiage.rs
@@ -30,3 +30,4 @@ pub const PROCESS: &str = "The executable name including extension.";
 pub const PARENT: &str = "The parent executable name, and optional excludes of child processes.";
 pub const EXCLUDES_HINT: &str = "Exclude a child process.";
 pub const RENAME_HINT: &str = "Right click to rename.";
+pub const TRAY_QUIT: &str = "Quit";

From c0b38721778354c596e7fc693f83d98b7716805f Mon Sep 17 00:00:00 2001
From: Matthew Wilding <mbwilding@gmail.com>
Date: Sun, 17 Dec 2023 22:17:32 +0800
Subject: [PATCH 39/39] Update

---
 dygma-layer-switcher/src/app.rs      | 6 +++---
 dygma-layer-switcher/src/verbiage.rs | 1 +
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/dygma-layer-switcher/src/app.rs b/dygma-layer-switcher/src/app.rs
index a7a0cfd..32883c0 100644
--- a/dygma-layer-switcher/src/app.rs
+++ b/dygma-layer-switcher/src/app.rs
@@ -140,8 +140,8 @@ impl DygmaLayerSwitcher {
                                 {
                                     self.remove_hidden_layer = Some(*layer);
                                 }
-                                ui.label(format!("{}", layer + 1));
-                                ui.label(self.mappings[layer].name.as_str());
+                                ui.label(self.mappings[layer].name.as_str())
+                                    .on_hover_text(format!("{} {}.", verbiage::LAYER, layer + 1));
                             });
                         }
                         if let Some(layer) = self.remove_hidden_layer {
@@ -180,9 +180,9 @@ impl DygmaLayerSwitcher {
                             if ui.button("👁").clicked() {
                                 self.hidden_layers.insert(*index);
                             }
-                            ui.label(format!("{}", index + 1));
                             editable_collapsing(ui, &mut layer.name, &mut layer.is_editing, |ui| {
                                 ui.horizontal(|ui| {
+                                    ui.label(format!("{} {}", verbiage::LAYER, index + 1));
                                     if ui
                                         .button(verbiage::BUTTON_ADD_WINDOW)
                                         .on_hover_text(verbiage::WINDOW)
diff --git a/dygma-layer-switcher/src/verbiage.rs b/dygma-layer-switcher/src/verbiage.rs
index dc6fe50..f12ed55 100644
--- a/dygma-layer-switcher/src/verbiage.rs
+++ b/dygma-layer-switcher/src/verbiage.rs
@@ -31,3 +31,4 @@ pub const PARENT: &str = "The parent executable name, and optional excludes of c
 pub const EXCLUDES_HINT: &str = "Exclude a child process.";
 pub const RENAME_HINT: &str = "Right click to rename.";
 pub const TRAY_QUIT: &str = "Quit";
+pub const LAYER: &str = "Layer";