From 0abe9a8206ae8780a0e296a0787394e0b89bf3b1 Mon Sep 17 00:00:00 2001
From: Lyra <firewire0x8@protonmail.com>
Date: Wed, 16 Sep 2026 22:26:22 -0400
Subject: [PATCH] Menu bar + settings window + about window

---
 Cargo.lock           |   1 +
 Cargo.toml           |   3 +-
 src/app.rs           |  32 ++++++------
 src/main.rs          |  29 +++++++----
 src/test_layer.rs    |  25 ---------
 src/top_bar_layer.rs | 118 +++++++++++++++++++++++++++++++++++++++++++
 src/video_quality.rs |  34 +++++++++++++
 7 files changed, 190 insertions(+), 52 deletions(-)
 delete mode 100644 src/test_layer.rs
 create mode 100644 src/top_bar_layer.rs
 create mode 100644 src/video_quality.rs

diff --git a/Cargo.lock b/Cargo.lock
index 5434556..41d9b94 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6338,6 +6338,7 @@ dependencies = [
  "tokio",
  "tracing",
  "tracing-subscriber",
+ "webbrowser",
  "yt-dlp",
 ]
 
diff --git a/Cargo.toml b/Cargo.toml
index c17a233..ad740d8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,6 +13,7 @@ serde_json = "1.0.151"
 tokio = {version = "1.53.1", features = ["macros", "rt-multi-thread"]}
 tracing = "0.1.44"
 tracing-subscriber = {version = "0.3.23", features = ["env-filter"]}
+webbrowser = "1.2.4"
 yt-dlp = "2.8.3"
 
 [profile.release]
@@ -24,4 +25,4 @@ debug-assertions = false
 incremental = false
 rpath = false
 codegen-units = 1
-strip = true
\ No newline at end of file
+strip = true
diff --git a/src/app.rs b/src/app.rs
index 7aa8ea2..16c2bde 100644
--- a/src/app.rs
+++ b/src/app.rs
@@ -1,21 +1,21 @@
-use std::time::Duration;
-use eframe::{Frame, Storage, CreationContext};
 use eframe::egui::{Context, Ui};
+use eframe::{CreationContext, Frame, Storage};
 use serde::{Deserialize, Serialize};
+use std::time::Duration;
 use yt_dlp::model::VideoQuality;
 
 pub(crate) struct Application {
-    settings: AppSettings,
-    layers:  Vec<Box<dyn crate::layer::Layer>>,
+    pub settings: AppSettings,
+    layers: Vec<Box<dyn crate::layer::Layer>>,
     data: Data,
 }
 
 #[derive(Serialize, Deserialize, Default)]
-struct AppSettings {
-    use_cookies: bool,
-    use_firefox_cookies: bool,
-    use_chrome_cookies: bool,
-    save_thumbnails: bool,
+pub struct AppSettings {
+    pub(crate) use_firefox_cookies: bool,
+    pub(crate) use_chrome_cookies: bool,
+    pub(crate) save_thumbnails: bool,
+    pub(crate) video_download_quality: crate::video_quality::VideoDownloadQuality,
 }
 
 #[derive(Serialize, Deserialize, Default)]
@@ -31,6 +31,7 @@ struct Video {
     uuid: String,
     original_url: String,
     video_path: String,
+    has_thumbnail: bool,
     thumbnail_path: String,
     thumbnail_path_low_quality: String,
     video_quality: VideoQuality,
@@ -43,11 +44,11 @@ struct Playlist {
     original_url: String,
     videos: Vec<Video>,
     creator: String,
+    has_thumbnail: bool,
     thumbnail_path: String,
     thumbnail_path_low_quality: String,
 }
 
-
 impl Application {
     pub fn new(cc: &CreationContext, layers: Vec<Box<dyn crate::layer::Layer>>) -> Self {
         let mut settings = AppSettings::default();
@@ -68,12 +69,15 @@ impl Application {
             }
         }
 
-        Self { settings, layers, data }
+        Self {
+            settings,
+            layers,
+            data,
+        }
     }
 }
 
 impl eframe::App for Application {
-
     fn logic(&mut self, ctx: &Context, frame: &mut Frame) {
         let mut layers = std::mem::take(&mut self.layers);
         for layer in &mut layers {
@@ -111,6 +115,4 @@ impl eframe::App for Application {
     fn auto_save_interval(&self) -> Duration {
         Duration::from_secs(5)
     }
-
-
-}
\ No newline at end of file
+}
diff --git a/src/main.rs b/src/main.rs
index 037e33e..688a4a4 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,14 +1,15 @@
+use crate::top_bar_layer::TopBarLayer;
 use std::fs;
 use std::path::PathBuf;
 use std::process::exit;
 use tracing::{debug, error};
-use crate::test_layer::TestLayer;
 
-mod logging;
-mod args;
 mod app;
+mod args;
 mod layer;
-mod test_layer;
+mod logging;
+mod top_bar_layer;
+mod video_quality;
 
 fn main() {
     let args = args::parse_args();
@@ -16,7 +17,9 @@ fn main() {
     debug!("Using args: \n{:#?}\n", args);
     let data_dir_path = PathBuf::from(&args.data_dir);
     if data_dir_path.is_file() {
-        error!("data_dir is a file... If you have set the data_dir manually, please pass in a directory. If you didn't pass in a path at all, please report this.");
+        error!(
+            "data_dir is a file... If you have set the data_dir manually, please pass in a directory. If you didn't pass in a path at all, please report this."
+        );
         error!("{:#?}", args);
         exit(1);
     }
@@ -28,14 +31,18 @@ fn main() {
     }
 
     let mut layers: Vec<Box<dyn layer::Layer>> = Vec::new();
-    layers.push(Box::new(TestLayer::default()));
+    layers.push(Box::new(TopBarLayer::default()));
 
     let mut options = eframe::NativeOptions::default();
-    options.persistence_path = Some(args.state.parse().expect("Failed to parse state config file path into path"));
+    options.persistence_path = Some(
+        args.state
+            .parse()
+            .expect("Failed to parse state config file path into path"),
+    );
     eframe::run_native(
         "yt-offline",
         options,
-        Box::new(|cc| {
-            Ok(Box::new(app::Application::new(cc, layers)))
-        })).expect("TODO: panic message");
-}
\ No newline at end of file
+        Box::new(|cc| Ok(Box::new(app::Application::new(cc, layers)))),
+    )
+    .expect("TODO: panic message");
+}
diff --git a/src/test_layer.rs b/src/test_layer.rs
deleted file mode 100644
index a91058b..0000000
--- a/src/test_layer.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-use eframe::egui::{Context, Ui};
-use eframe::{egui, Frame};
-use crate::app;
-use crate::layer::Layer;
-
-#[derive(Default)]
-pub struct TestLayer {
-    test_string: String,
-}
-
-impl Layer for TestLayer {
-    fn logic(&mut self, application: &mut app::Application, ctx: &Context, frame: &mut Frame) {
-
-    }
-
-    fn ui(&mut self, application: &mut app::Application, ui: &mut Ui, frame: &mut Frame) {
-        egui::CentralPanel::default().show(ui, |ui| {
-            ui.heading("Hello from the test_layer!");
-            ui.text_edit_singleline(&mut self.test_string);
-            if ui.button("Print test_string in layer").clicked() {
-                println!("{}", self.test_string);
-            }
-        });
-    }
-}
\ No newline at end of file
diff --git a/src/top_bar_layer.rs b/src/top_bar_layer.rs
new file mode 100644
index 0000000..2ed86ed
--- /dev/null
+++ b/src/top_bar_layer.rs
@@ -0,0 +1,118 @@
+use crate::app::Application;
+use crate::layer::Layer;
+use crate::video_quality::VideoDownloadQuality;
+use eframe::egui::{Context, Ui};
+use eframe::{Frame, egui};
+use tracing::warn;
+
+#[derive(Default)]
+pub struct TopBarLayer {
+    show_settings_window: bool,
+    show_about_window: bool,
+}
+
+impl Layer for TopBarLayer {
+    fn logic(&mut self, application: &mut Application, ctx: &Context, frame: &mut Frame) {}
+
+    fn ui(&mut self, application: &mut Application, ui: &mut Ui, frame: &mut Frame) {
+        egui::MenuBar::new().ui(ui, |ui: &mut Ui| {
+            ui.menu_button("File", |ui: &mut Ui| {
+                if ui.button("Settings").clicked() {
+                    self.show_settings_window = true;
+                }
+                if ui.button("Exit").clicked() {
+                    ui.send_viewport_cmd(eframe::egui::ViewportCommand::Close);
+                }
+            });
+            ui.menu_button("Help", |ui: &mut Ui| {
+                if ui.button("About").clicked() {
+                    self.show_about_window = true;
+                }
+                if ui.button("Git").clicked() {
+                    if let Err(e) =
+                        webbrowser::open("https://git.catgirls.fish/firewire/yt-offline")
+                    {
+                        warn!("Failed to open web browser: {}", e);
+                    }
+                }
+            });
+        });
+
+        if self.show_settings_window {
+            egui::Window::new("Settings")
+                .open(&mut self.show_settings_window)
+                .show(ui, |ui: &mut Ui| {
+                    if ui
+                        .checkbox(
+                            &mut application.settings.use_firefox_cookies,
+                            "Use cookies from Firefox",
+                        )
+                        .clicked()
+                    {
+                        if application.settings.use_chrome_cookies {
+                            application.settings.use_chrome_cookies = false;
+                        }
+                    };
+                    if ui
+                        .checkbox(
+                            &mut application.settings.use_chrome_cookies,
+                            "Use cookies from Chrome",
+                        )
+                        .clicked()
+                    {
+                        if application.settings.use_firefox_cookies {
+                            application.settings.use_firefox_cookies = false;
+                        }
+                    };
+                    ui.checkbox(&mut application.settings.save_thumbnails, "Save thumbnails");
+                    ui.menu_button("Video download quality", |ui: &mut Ui| {
+                        ui.radio_value(
+                            &mut application.settings.video_download_quality,
+                            VideoDownloadQuality::Best,
+                            "Best",
+                        );
+                        ui.radio_value(
+                            &mut application.settings.video_download_quality,
+                            VideoDownloadQuality::High,
+                            "High",
+                        );
+                        ui.radio_value(
+                            &mut application.settings.video_download_quality,
+                            VideoDownloadQuality::Medium,
+                            "Medium",
+                        );
+                        ui.radio_value(
+                            &mut application.settings.video_download_quality,
+                            VideoDownloadQuality::Low,
+                            "Low",
+                        );
+                        ui.radio_value(
+                            &mut application.settings.video_download_quality,
+                            VideoDownloadQuality::Worst,
+                            "Worst",
+                        );
+                    });
+                });
+        }
+
+        if self.show_about_window {
+            egui::Window::new("About")
+                .open(&mut self.show_about_window)
+                .show(ui, |ui: &mut Ui| {
+                    ui.heading("yt-offline");
+                    ui.label("A simple unified offline YouTube downloader + viewer");
+                    ui.label("Created by Lyra in Rust <3");
+                    ui.separator();
+                    ui.label("Honorable mentions:");
+                    ui.horizontal(|ui| {
+                        ui.label("yt-dlp");
+                        ui.hyperlink("https://github.com/yt-dlp/yt-dlp");
+                    });
+                    ui.horizontal(|ui| {
+                        ui.label("egui");
+                        ui.hyperlink("https://github.com/emilk/egui");
+                    });
+                });
+        }
+    }
+}
diff --git a/src/video_quality.rs b/src/video_quality.rs
new file mode 100644
index 0000000..25068cb
--- /dev/null
+++ b/src/video_quality.rs
@@ -0,0 +1,34 @@
+use serde::{Deserialize, Serialize};
+use yt_dlp::model::VideoQuality;
+
+#[derive(Deserialize, Serialize, PartialEq, Default)]
+pub enum VideoDownloadQuality {
+    #[default]
+    Best,
+    High,
+    Medium,
+    Low,
+    Worst,
+}
+
+impl VideoDownloadQuality {
+    pub fn to_ytdlp(&self) -> VideoQuality {
+        match self {
+            VideoDownloadQuality::Best => VideoQuality::Best,
+            VideoDownloadQuality::High => VideoQuality::High,
+            VideoDownloadQuality::Medium => VideoQuality::Medium,
+            VideoDownloadQuality::Low => VideoQuality::Low,
+            VideoDownloadQuality::Worst => VideoQuality::Worst,
+        }
+    }
+
+    pub fn to_string(&self) -> String {
+        match self {
+            VideoDownloadQuality::Best => "best".to_string(),
+            VideoDownloadQuality::High => "high".to_string(),
+            VideoDownloadQuality::Medium => "medium".to_string(),
+            VideoDownloadQuality::Low => "low".to_string(),
+            VideoDownloadQuality::Worst => "worst".to_string(),
+        }
+    }
+}