diff --git a/app/tauri/src/commands.rs b/app/tauri/src/commands.rs index 4344448e..cf043da8 100644 --- a/app/tauri/src/commands.rs +++ b/app/tauri/src/commands.rs @@ -3,7 +3,7 @@ use std::sync::Mutex; // Learn more about Tauri commands at https://tauri.app/v1/guides/features/command -use tauri::{Builder, PhysicalSize, Runtime, Wry}; +use tauri::{Builder, LogicalSize, Runtime, Wry}; #[non_exhaustive] struct WindowSize; @@ -12,13 +12,18 @@ use crate::system_tray; use crate::updater; impl WindowSize { - // Not sure why, if its due to UI scaling or what though these values seem to size smaller than the same values on electron - pub const MIN: PhysicalSize = PhysicalSize { width : 420, height: 602}; - pub const COMPACT: PhysicalSize = PhysicalSize { width : 420, height: 80}; + pub const MIN: LogicalSize = LogicalSize { + width: 420, + height: 602, + }; + pub const COMPACT: LogicalSize = LogicalSize { + width: 420, + height: 80, + }; } -static ORIGINAL_SIZE: Mutex> = Mutex::new(WindowSize::MIN); +static ORIGINAL_SIZE: Mutex> = Mutex::new(WindowSize::MIN); static HAS_DECORATIONS: Mutex = Mutex::new(true); static IS_COMPACT: Mutex = Mutex::new(false); @@ -55,8 +60,15 @@ fn set_always_on_top(always_on_top: bool, window: tauri::Window) } #[tauri::command] -fn set_fullscreen_break(should_fullscreen: bool, always_on_top: bool, window: tauri::Window) { - println!("set_fullscreen_break! {} {}", should_fullscreen, always_on_top); +fn set_fullscreen_break( + should_fullscreen: bool, + always_on_top: bool, + window: tauri::Window, +) { + println!( + "set_fullscreen_break! {} {}", + should_fullscreen, always_on_top + ); try_set_always_on_top(always_on_top, &window); if should_fullscreen { try_set_native_titlebar(true, &window); @@ -84,14 +96,15 @@ fn try_set_always_on_top(always_on_top: bool, window: &tauri::Window } } -fn try_set_min_size(size: Option>, window: &tauri::Window) { - match window.set_min_size(size) {//Some(size)) { +fn try_set_min_size(size: Option>, window: &tauri::Window) { + match window.set_min_size(size) { + //Some(size)) { Ok(_) => (), Err(e) => println!("There was a problem setting min size! {:?}", e), } } -fn try_set_size(size: PhysicalSize, window: &tauri::Window) { +fn try_set_size(size: LogicalSize, window: &tauri::Window) { match window.set_size(size) { Ok(_) => (), Err(e) => println!("There was a problem setting the window size! {:?}", e), @@ -103,27 +116,33 @@ fn try_set_resizeable(resizeable: bool, window: &tauri::Window) { println!("Window resizeable {:?}", resizeable); match window.set_resizable(resizeable) { Ok(_) => (), - Err(e) => println!("There was a problem making the window resizeable {:?}", e) + Err(e) => println!("There was a problem making the window resizeable {:?}", e), } } // Atm resizeable seems to cause a problem where the size cannot be set smaller than a certain amount // https://github.com/tauri-apps/tao/issues/561, just use resizeable until this is fixed. -fn set_window_fixed_size(size: PhysicalSize, window: &tauri::Window) { +fn set_window_fixed_size(size: LogicalSize, window: &tauri::Window) { let decorations = HAS_DECORATIONS.lock().unwrap(); let new_height = size.height + (if *decorations { 0 } else { 34 }); - let new_size = PhysicalSize { width : size.width, height: new_height}; + let new_size = LogicalSize { + width: size.width, + height: new_height, + }; try_set_size(new_size, window); try_set_resizeable(false, window); } -fn set_window_resizeable(min_size: PhysicalSize, size: PhysicalSize, window: &tauri::Window) { +fn set_window_resizeable( + min_size: LogicalSize, + size: LogicalSize, + window: &tauri::Window, +) { try_set_resizeable(true, window); try_set_size(size, window); try_set_min_size(Some(min_size), window); } - #[tauri::command] fn set_compact_mode(compact_mode: bool, window: tauri::Window) { { @@ -134,11 +153,18 @@ fn set_compact_mode(compact_mode: bool, window: tauri::Window) { if compact_mode { { let mut size = ORIGINAL_SIZE.lock().unwrap(); - *size = window.outer_size().unwrap().clone(); + *size = window + .outer_size() + .unwrap() + .to_logical(window.scale_factor().unwrap()); } set_window_fixed_size(WindowSize::COMPACT, &window); } else { - set_window_resizeable(WindowSize::MIN, ORIGINAL_SIZE.lock().unwrap().clone(), &window); + set_window_resizeable( + WindowSize::MIN, + ORIGINAL_SIZE.lock().unwrap().clone(), + &window, + ); } } @@ -164,28 +190,38 @@ fn set_native_titlebar(use_native_titlebar: bool, window: tauri::Win fn try_set_native_titlebar(use_native_titlebar: bool, window: &tauri::Window) { match window.set_decorations(use_native_titlebar) { Ok(_) => (), - Err(e) => println!("There was a problem setting the window decorations! {:?}", e), + Err(e) => println!( + "There was a problem setting the window decorations! {:?}", + e + ), } println!("set_native_titlebar! {}", use_native_titlebar); } - /** - * We could do this by passing the object into a custom function that adds the commands but I wanted - * to practice more with rust. Plus it makes the setup cleaner. +* We could do this by passing the object into a custom function that adds the commands but I wanted +* to practice more with rust. Plus it makes the setup cleaner. - * Switch to a function that takes and returns tauri::Builder or uses a reference if we need to - * switch it. - */ +* Switch to a function that takes and returns tauri::Builder or uses a reference if we need to +* switch it. +*/ pub trait PomatezCommands { fn register_pomatez_commands(self) -> tauri::Builder; } impl PomatezCommands for Builder { fn register_pomatez_commands(self) -> tauri::Builder { - self.invoke_handler(tauri::generate_handler![set_show, set_always_on_top, - set_fullscreen_break, set_compact_mode, set_ui_theme, set_native_titlebar, - system_tray::tray_icon_update, set_close, set_minimize, updater::check_for_updates, + self.invoke_handler(tauri::generate_handler![ + set_show, + set_always_on_top, + set_fullscreen_break, + set_compact_mode, + set_ui_theme, + set_native_titlebar, + system_tray::tray_icon_update, + set_close, + set_minimize, + updater::check_for_updates, updater::install_update ]) } diff --git a/app/tauri/src/main.rs b/app/tauri/src/main.rs index d8c81c24..304280ec 100644 --- a/app/tauri/src/main.rs +++ b/app/tauri/src/main.rs @@ -1,27 +1,31 @@ #![cfg_attr( -all(not(debug_assertions), target_os = "windows"), -windows_subsystem = "windows" + all(not(debug_assertions), target_os = "windows"), + windows_subsystem = "windows" )] #[cfg(debug_assertions)] -use tauri::{Manager}; -use tauri::{RunEvent}; +use tauri::Manager; +use tauri::RunEvent; use tauri_plugin_autostart::MacosLauncher; use tauri_plugin_window; #[macro_use] mod commands; -mod system_tray; mod global_shortcuts; +mod main_window; +mod system_tray; mod updater; use commands::PomatezCommands; +use global_shortcuts::{PomatezGlobalShortcutsRegister, PomatezGlobalShortcutsSetup}; use system_tray::PomatezTray; -use global_shortcuts::{PomatezGlobalShortcutsSetup, PomatezGlobalShortcutsRegister}; fn main() { let app = tauri::Builder::default() - .plugin(tauri_plugin_autostart::init(MacosLauncher::LaunchAgent, None)) + .plugin(tauri_plugin_autostart::init( + MacosLauncher::LaunchAgent, + None, + )) .plugin(tauri_plugin_window::init()) .plugin(tauri_plugin_shell::init()) .plugin(tauri_plugin_notification::init()) @@ -30,6 +34,7 @@ fn main() { .setup(|app| { #[cfg(desktop)] { + main_window::create_main_window(&app.handle()); app.setup_global_shortcuts(); app.set_pomatez_system_tray(); } @@ -49,6 +54,9 @@ fn main() { println!("Pomatez is ready"); } + RunEvent::ExitRequested { api, .. } => { + api.prevent_exit(); + } _ => {} }); } diff --git a/app/tauri/src/main_window.rs b/app/tauri/src/main_window.rs new file mode 100644 index 00000000..98df3417 --- /dev/null +++ b/app/tauri/src/main_window.rs @@ -0,0 +1,24 @@ +use tauri::{AppHandle, Manager, WindowBuilder}; + +pub static MAIN_WINDOW_ID: &str = "main"; + +pub fn create_main_window(handle: &AppHandle) { + if handle.get_window(MAIN_WINDOW_ID).is_some() { + return; + } + let window = WindowBuilder::new(handle, MAIN_WINDOW_ID, Default::default()) + .inner_size(340f64, 502f64) + .resizable(true) + .title("pomatez") + .build() + .unwrap(); + + let window_clone = window.clone(); + window.on_window_event(move |e| match e { + tauri::WindowEvent::CloseRequested { api, .. } => { + api.prevent_close(); + window_clone.hide().unwrap(); + } + _ => {} + }) +} diff --git a/app/tauri/src/system_tray.rs b/app/tauri/src/system_tray.rs index 026c13fa..b40f2e57 100644 --- a/app/tauri/src/system_tray.rs +++ b/app/tauri/src/system_tray.rs @@ -1,14 +1,16 @@ use std::path::PathBuf; -use tauri::{App, Icon, Manager, Runtime}; +use tauri::path::BaseDirectory; use tauri::{ menu::{MenuBuilder, MenuItemBuilder}, tray::{ClickType, TrayIconBuilder}, }; -use tauri::path::BaseDirectory; +use tauri::{App, Icon, Manager, Runtime}; use base64; -use base64::Engine; use base64::engine::general_purpose; +use base64::Engine; + +use crate::main_window; #[tauri::command] pub fn tray_icon_update(data_url: String, window: tauri::Window) { @@ -33,7 +35,6 @@ pub fn tray_icon_update(data_url: String, window: tauri::Window) } } - /** * We could do this by passing the object into a custom function that adds the commands but I wanted * to practice more with rust. Plus it makes the setup cleaner. @@ -46,11 +47,10 @@ pub trait PomatezTray { } impl PomatezTray for App { - /* * The icon is updated after rendering on the frontend so that is handled in the commands file. * However the initial setup and behavior is handled here. - */ + */ fn set_pomatez_system_tray(&self) { println!("Setting system tray"); // Was defined in tauri.config.json to start in v1 @@ -58,10 +58,17 @@ impl PomatezTray for App { let show = MenuItemBuilder::with_id("show", "Show").build(self); let quit = MenuItemBuilder::with_id("quit", "Quit").build(self); - let menu = MenuBuilder::new(self).items(&[&show, &quit]).build().expect("failed to build menu"); + let menu = MenuBuilder::new(self) + .items(&[&show, &quit]) + .build() + .expect("failed to build menu"); - let icon_path = self.path().resolve::("icons/icon.png".into(), BaseDirectory::Resource) - .expect("failed to resolve icon path, this should not happen as it is an internal file"); + let icon_path = self + .path() + .resolve::("icons/icon.png".into(), BaseDirectory::Resource) + .expect( + "failed to resolve icon path, this should not happen as it is an internal file", + ); let _ = TrayIconBuilder::new() .menu(&menu) @@ -80,12 +87,14 @@ impl PomatezTray for App { .on_tray_icon_event(|tray, event| { if event.click_type == ClickType::Left { let app = tray.app_handle(); + main_window::create_main_window(app); let window = app.get_window("main").unwrap(); window.show().unwrap(); window.set_focus().unwrap(); } }) .icon(Icon::File(icon_path)) - .build(self).expect("failed to build tray icon"); + .build(self) + .expect("failed to build tray icon"); } } diff --git a/app/tauri/tauri.conf.json b/app/tauri/tauri.conf.json index 5d1052f6..456a65e1 100644 --- a/app/tauri/tauri.conf.json +++ b/app/tauri/tauri.conf.json @@ -36,18 +36,9 @@ "signingIdentity": null }, "publisher": "Roldan Montilla Jr", - "resources": [ - "icons/icon.png" - ], + "resources": ["icons/icon.png"], "shortDescription": "", - "targets": [ - "deb", - "appimage", - "msi", - "nsis", - "dmg", - "updater" - ], + "targets": ["deb", "appimage", "msi", "nsis", "dmg", "updater"], "windows": { "certificateThumbprint": null, "digestAlgorithm": "sha256", @@ -72,14 +63,9 @@ "security": { "csp": null }, - "windows": [ - { - "fullscreen": false, - "height": 502, - "resizable": true, - "title": "pomatez", - "width": 340 - } - ] + "windows": [] + }, + "plugins": { + "updater": {} } }