feat(ui): Window size setting (#1299)

common/src/state/ui.rs

@@ -119,6 +119,7 @@ pub struct WindowMeta {
     pub focused: bool,
     pub maximized: bool,
     pub minimized: bool,
+    pub full_screen: bool,
     pub minimal_view: bool, // We can use this to detect mobile or portrait mode
 }
 
@@ -195,8 +196,8 @@ pub struct UI {
     pub active_welcome: bool,
     pub sidebar_hidden: bool,
     pub window_maximized: bool,
-    pub window_width: u32,
-    pub window_height: u32,
+    pub window_size: Option<(u32, u32)>,
+    pub window_position: Option<(i32, i32)>,
     pub metadata: WindowMeta,
     #[serde(default = "default_emojis")]
     pub emojis: EmojiCounter,
@@ -235,8 +236,8 @@ impl Default for UI {
             active_welcome: Default::default(),
             sidebar_hidden: Default::default(),
             window_maximized: Default::default(),
-            window_width: Default::default(),
-            window_height: Default::default(),
+            window_size: None,
+            window_position: None,
             metadata: Default::default(),
             emojis: default_emojis(),
             emoji_destination: Default::default(),

ui/src/bootstrap.rs

@@ -44,13 +44,14 @@ pub(crate) fn use_boostrap<'a>(
             state.ui.overlays.push(window);
         }
 
-        let size = desktop.webview.inner_size();
+        let size = scaled_window_size(desktop.webview.inner_size(), desktop);
         // Update the window metadata now that we've created a window
         let window_meta = WindowMeta {
             focused: desktop.is_focused(),
             maximized: desktop.is_maximized(),
             minimized: desktop.is_minimized(),
-            minimal_view: size.width < get_window_minimal_width(desktop),
+            full_screen: state.ui.metadata.full_screen,
+            minimal_view: size.width < 600,
         };
         state.ui.metadata = window_meta;
         state.set_warp_ch(WARP_CMD_CH.tx.clone());

ui/src/layouts/unlock.rs

@@ -223,10 +223,7 @@ pub fn UnlockLayout(cx: Scope, page: UseState<AuthPages>, pin: UseRef<String>) -
                                 shown_error.set(String::new());
                             }
                             if validation_passed {
-                                let outer_size = desktop.outer_size();
                                 let is_maximized = desktop.is_maximized();
-                                state.write_silent().ui.window_height = outer_size.height;
-                                state.write_silent().ui.window_width = outer_size.width;
                                 state.write_silent().ui.window_maximized = is_maximized;
                                 let _ = state.write_silent().save();
                                 cmd_in_progress.set(true);

ui/src/main.rs

@@ -15,6 +15,7 @@ use common::warp_runner::WarpEvent;
 use common::{get_extras_dir, warp_runner, LogProfile, STATIC_ARGS, WARP_CMD_CH, WARP_EVENT_CH};
 
 use dioxus::prelude::*;
+use dioxus_desktop::tao::dpi::{LogicalPosition, PhysicalPosition};
 use dioxus_desktop::{
     tao::{dpi::LogicalSize, event::WindowEvent},
     use_window,
@@ -53,7 +54,7 @@ use crate::layouts::settings::SettingsLayout;
 use crate::layouts::storage::files_layout::FilesLayout;
 use crate::misc_scripts::*;
 use dioxus_desktop::wry::application::event::Event as WryEvent;
-use dioxus_desktop::{use_wry_event_handler, DesktopService};
+use dioxus_desktop::{use_wry_event_handler, DesktopService, PhysicalSize};
 use tokio::sync::{mpsc, Mutex};
 use tokio::time::{sleep, Duration};
 use warp::logging::tracing::log::{self, LevelFilter};
@@ -340,29 +341,65 @@ fn use_app_coroutines(cx: &ScopeState) -> Option<()> {
             } => state
                 .write()
                 .mutate(Action::ClearAllPopoutWindows(desktop.clone())),
+            WryEvent::WindowEvent {
+                event: WindowEvent::Moved(_),
+                ..
+            } => {
+                // Dont use the arg provided by the WindowEvent as its not right on mac
+                let position =
+                    scaled_window_position(desktop.outer_position().unwrap_or_default(), &desktop);
+                state.write_silent().ui.window_position = Some((position.x, position.y));
+                let _ = state.write().save();
+            }
             WryEvent::WindowEvent {
                 event: WindowEvent::Resized(_),
                 ..
             } => {
-                if state.read().ui.window_maximized
-                    && *first_resize.read()
-                    && cfg!(not(target_os = "windows"))
-                {
-                    desktop.set_inner_size(LogicalSize::new(950.0, 600.0));
+                let current_position =
+                    scaled_window_position(desktop.outer_position().unwrap_or_default(), &desktop);
+                let (pos_x, pos_y) = state
+                    .read()
+                    .ui
+                    .window_position
+                    .unwrap_or(current_position.into());
+                let (width, height) = state.read().ui.window_size.unwrap_or((950, 600));
+                if *first_resize.read() {
+                    if state.read().ui.metadata.full_screen {
+                        desktop.set_fullscreen(true);
+                    } else {
+                        desktop.set_inner_size(LogicalSize::new(width, height));
+                        desktop.set_maximized(state.read().ui.metadata.maximized);
+                    }
+                    desktop.set_outer_position(LogicalPosition::new(pos_x, pos_y));
                     *first_resize.write_silent() = false;
                 }
-                let size = webview.inner_size();
+                let size = scaled_window_size(webview.inner_size(), &desktop);
                 let metadata = state.read().ui.metadata.clone();
-                //log::debug!("resize {:?}", size);
                 let new_metadata = WindowMeta {
                     focused: desktop.is_focused(),
                     maximized: desktop.is_maximized(),
                     minimized: desktop.is_minimized(),
-                    minimal_view: size.width < get_window_minimal_width(&desktop),
+                    full_screen: desktop.fullscreen().is_some(),
+                    minimal_view: size.width < 600,
                 };
+                let mut changed = false;
                 if metadata != new_metadata {
-                    state.write().ui.sidebar_hidden = new_metadata.minimal_view;
-                    state.write().ui.metadata = new_metadata;
+                    state.write_silent().ui.sidebar_hidden = new_metadata.minimal_view;
+                    state.write_silent().ui.metadata = new_metadata;
+                    changed = true;
+                }
+                if size.width != width || size.height != height {
+                    state.write_silent().ui.window_size = Some((size.width, size.height));
+                    let _ = state.write_silent().save();
+                    changed = true;
+                }
+                if current_position.x != pos_x || current_position.y != pos_y {
+                    state.write_silent().ui.window_position =
+                        Some((current_position.x, current_position.y));
+                    changed = true;
+                }
+                if changed {
+                    let _ = state.write().save();
                 }
             }
             _ => {}
@@ -968,13 +1005,33 @@ fn get_extensions() -> Result<HashMap<String, UplinkExtension>, Box<dyn std::err
     Ok(extensions)
 }
 
-fn get_window_minimal_width(desktop: &std::rc::Rc<DesktopService>) -> u32 {
+fn scaled_window_size(
+    inner: PhysicalSize<u32>,
+    desktop: &std::rc::Rc<DesktopService>,
+) -> PhysicalSize<u32> {
     if cfg!(target_os = "macos") {
         // On Mac window sizes are kinda funky.
         // They are scaled with the window scale factor so they dont correspond to app pixels
-        (600_f64 * desktop.webview.window().scale_factor()) as u32
+        let logical: LogicalSize<f64> = (inner.width as f64, inner.height as f64).into();
+        let scale = desktop.webview.window().scale_factor();
+        logical.to_physical(1_f64 / scale)
+    } else {
+        inner
+    }
+}
+
+fn scaled_window_position(
+    position: PhysicalPosition<i32>,
+    desktop: &std::rc::Rc<DesktopService>,
+) -> PhysicalPosition<i32> {
+    if cfg!(target_os = "macos") {
+        // On Mac window the positions are kinda funky.
+        // They are scaled with the window scale factor so they dont correspond to actual position
+        let logical: LogicalPosition<f64> = (position.x as f64, position.y as f64).into();
+        let scale = desktop.webview.window().scale_factor();
+        logical.to_physical(1_f64 / scale)
     } else {
-        600
+        position
     }
 }