@ -2,6 +2,7 @@
// SPDX-License-Identifier: Apache-2.0
// SPDX-License-Identifier: Apache-2.0
// SPDX-License-Identifier: MIT
// SPDX-License-Identifier: MIT
use bitflags ::bitflags ;
use serde ::{ Deserialize , Serialize } ; use serde ::{ Deserialize , Serialize } ;
use tauri ::{ use tauri ::{
plugin ::{ Builder as PluginBuilder , TauriPlugin } , plugin ::{ Builder as PluginBuilder , TauriPlugin } ,
@ -30,27 +31,27 @@ pub enum Error {
Bincode ( #[ from ] Box < bincode ::ErrorKind > ) , Bincode ( #[ from ] Box < bincode ::ErrorKind > ) ,
} }
/// Defines how the window visibility should be restored.
pub type Result < T > = std ::result ::Result < T , Error > ;
#[ derive(Debug, Copy, Clone, Eq, PartialEq) ]
pub enum ShowMode { bitflags ! {
/// The window will always be shown, regardless of what the last stored state was.
pub struct StateFlags : u32 {
Always , const SIZE = 1 < < 0 ;
/// The window will be automatically shown if the last stored state for visibility was `true`.
const POSITION = 1 < < 1 ;
LastSaved , const MAXIMIZED = 1 < < 2 ;
/// The window will not be automatically shown by this plugin.
const VISIBLE = 1 < < 3 ;
Never , const DECORATIONS = 1 < < 4 ;
const FULLSCREEN = 1 < < 5 ;
}
} }
impl Default for S howMode { impl Default for S tateFlags {
fn default ( ) -> Self { fn default ( ) -> Self {
Self ::LastSaved Self ::all( )
} }
} }
pub type Result < T > = std ::result ::Result < T , Error > ;
#[ derive(Debug, Default, Deserialize, Serialize) ] #[ derive(Debug, Default, Deserialize, Serialize) ]
struct Window Metadata { struct WindowState {
width : f64 , width : f64 ,
height : f64 , height : f64 ,
x : i32 , x : i32 ,
@ -61,17 +62,23 @@ struct WindowMetadata {
fullscreen : bool , fullscreen : bool ,
} }
struct WindowStateCache ( Arc < Mutex < HashMap < String , Window Metadata > > > ) ; struct WindowStateCache ( Arc < Mutex < HashMap < String , Window State > > > ) ;
pub trait AppHandleExt { pub trait AppHandleExt {
fn save_window_state ( & self -> Result < ( ) > ; fn save_window_state ( & self , flags : StateFlags ) -> Result < ( ) > ;
} }
impl < R : Runtime > AppHandleExt for tauri ::AppHandle < R > { impl < R : Runtime > AppHandleExt for tauri ::AppHandle < R > {
fn save_window_state ( & self -> Result < ( ) > { fn save_window_state ( & self , flags : StateFlags ) -> Result < ( ) > {
if let Some ( app_dir ) = self . path_resolver ( ) . app_config_dir ( ) { if let Some ( app_dir ) = self . path_resolver ( ) . app_config_dir ( ) {
let state_path = app_dir . join ( STATE_FILENAME ) ; let state_path = app_dir . join ( STATE_FILENAME ) ;
let cache = self . state ::< WindowStateCache > ( ) ; let cache = self . state ::< WindowStateCache > ( ) ;
let state = cache . 0. lock ( ) . unwrap ( ) ; let mut state = cache . 0. lock ( ) . unwrap ( ) ;
for ( label , s ) in state . iter_mut ( ) {
if let Some ( window ) = self . get_window ( label ) {
window . update_state ( s , flags ) ? ;
}
}
create_dir_all ( & app_dir ) create_dir_all ( & app_dir )
. map_err ( Error ::Io ) . map_err ( Error ::Io )
. and_then ( | _ | File ::create ( state_path ) . map_err ( Into ::into ) ) . and_then ( | _ | File ::create ( state_path ) . map_err ( Into ::into ) )
@ -86,68 +93,146 @@ impl<R: Runtime> AppHandleExt for tauri::AppHandle<R> {
} }
pub trait WindowExt { pub trait WindowExt {
fn restore_state ( & self , show_mode: ShowMode ) -> tauri ::Result < ( ) > ; fn restore_state ( & self , flags: StateFlags ) -> tauri ::Result < ( ) > ;
} }
impl < R : Runtime > WindowExt for Window < R > { impl < R : Runtime > WindowExt for Window < R > {
fn restore_state ( & self , show_mode: ShowMode ) -> tauri ::Result < ( ) > { fn restore_state ( & self , flags: StateFlags ) -> tauri ::Result < ( ) > {
let cache = self . state ::< WindowStateCache > ( ) ; let cache = self . state ::< WindowStateCache > ( ) ;
let mut c = cache . 0. lock ( ) . unwrap ( ) ; let mut c = cache . 0. lock ( ) . unwrap ( ) ;
let mut should_show = true ; let mut should_show = true ;
if let Some ( state ) = c . get ( self . label ( ) ) { if let Some ( state ) = c . get ( self . label ( ) ) {
self . set_decorations ( state . decorated ) ? ; if flags . contains ( StateFlags ::DECORATIONS ) {
self . set_decorations ( state . decorated ) ? ;
self . set_size ( LogicalSize { }
width : state . width ,
height : state . height , if flags . contains ( StateFlags ::SIZE ) {
} ) ? ; self . set_size ( LogicalSize {
width : state . width ,
// restore position to saved value if saved monitor exists
height : state . height ,
// otherwise, let the OS decide where to place the window
} ) ? ;
for m in self . available_monitors ( ) ? { }
if m . contains ( ( state . x , state . y ) . into ( ) ) {
self . set_position ( PhysicalPosition { if flags . contains ( StateFlags ::POSITION ) {
x : state . x , // restore position to saved value if saved monitor exists
y : state . y , // otherwise, let the OS decide where to place the window
} ) ? ; for m in self . available_monitors ( ) ? {
if m . contains ( ( state . x , state . y ) . into ( ) ) {
self . set_position ( PhysicalPosition {
x : state . x ,
y : state . y ,
} ) ? ;
}
} }
} }
if state . maximized { if flags. contains ( StateFlags ::MAXIMIZED ) & & state. maximized {
self . maximize ( ) ? ; self . maximize ( ) ? ;
} }
self . set_fullscreen ( state . fullscreen ) ? ;
if flags . contains ( StateFlags ::FULLSCREEN ) {
self . set_fullscreen ( state . fullscreen ) ? ;
}
should_show = state . visible ; should_show = state . visible ;
} else { } else {
let mut metadata = WindowState ::default ( ) ;
if flags . contains ( StateFlags ::SIZE ) {
let scale_factor = self
. current_monitor ( ) ?
. map ( | m | m . scale_factor ( ) )
. unwrap_or ( 1. ) ;
let size = self . inner_size ( ) ? . to_logical ( scale_factor ) ;
metadata . width = size . width ;
metadata . height = size . height ;
}
if flags . contains ( StateFlags ::POSITION ) {
let pos = self . outer_position ( ) ? ;
metadata . x = pos . x ;
metadata . y = pos . y ;
}
if flags . contains ( StateFlags ::MAXIMIZED ) {
metadata . maximized = self . is_maximized ( ) ? ;
}
if flags . contains ( StateFlags ::VISIBLE ) {
metadata . visible = self . is_visible ( ) ? ;
}
if flags . contains ( StateFlags ::DECORATIONS ) {
metadata . visible = self . is_visible ( ) ? ;
}
if flags . contains ( StateFlags ::FULLSCREEN ) {
metadata . fullscreen = self . is_fullscreen ( ) ? ;
}
c . insert ( self . label ( ) . into ( ) , metadata ) ;
}
if flags . contains ( StateFlags ::VISIBLE ) & & should_show {
self . show ( ) ? ;
self . set_focus ( ) ? ;
}
Ok ( ( ) )
}
}
trait WindowExtInternal {
fn update_state ( & self , state : & mut WindowState , flags : StateFlags ) -> tauri ::Result < ( ) > ;
}
impl < R : Runtime > WindowExtInternal for Window < R > {
fn update_state ( & self , state : & mut WindowState , flags : StateFlags ) -> tauri ::Result < ( ) > {
let is_maximized = match flags . intersects ( StateFlags ::MAXIMIZED | StateFlags ::SIZE ) {
true = > self . is_maximized ( ) ? ,
false = > false ,
} ;
if flags . contains ( StateFlags ::MAXIMIZED ) {
state . maximized = is_maximized ;
}
if flags . contains ( StateFlags ::FULLSCREEN ) {
state . fullscreen = self . is_fullscreen ( ) ? ;
}
if flags . contains ( StateFlags ::DECORATIONS ) {
state . decorated = self . is_decorated ( ) ? ;
}
if flags . contains ( StateFlags ::VISIBLE ) {
state . visible = self . is_visible ( ) ? ;
}
if flags . contains ( StateFlags ::SIZE ) {
let scale_factor = self let scale_factor = self
. current_monitor ( ) ? . current_monitor ( ) ?
. map ( | m | m . scale_factor ( ) ) . map ( | m | m . scale_factor ( ) )
. unwrap_or ( 1. ) ; . unwrap_or ( 1. ) ;
let LogicalSize { width , height } = self . inner_size ( ) ? . to_logical ( scale_factor ) ; let size = self . inner_size ( ) ? . to_logical ( scale_factor ) ;
let PhysicalPosition { x , y } = self . outer_position ( ) ? ;
let maximized = self . is_maximized ( ) . unwrap_or ( false ) ; // It doesn't make sense to save a self with 0 height or width
let visible = self . is_visible ( ) . unwrap_or ( true ) ; if size . width > 0. & & size . height > 0. & & ! is_maximized {
let decorated = self . is_decorated ( ) . unwrap_or ( true ) ; state . width = size . width ;
let fullscreen = self . is_fullscreen ( ) . unwrap_or ( false ) ; state . height = size . height ;
c . insert ( }
self . label ( ) . into ( ) ,
WindowMetadata {
width ,
height ,
x ,
y ,
maximized ,
visible ,
decorated ,
fullscreen ,
} ,
) ;
} }
if show_mode = = ShowMode ::Always | | ( show_mode = = ShowMode ::LastSaved & & should_show ) { if flags . contains ( StateFlags ::POSITION ) {
self . show ( ) ? ; let position = self . inner_position ( ) ? ;
self . set_focus ( ) ? ; if let Ok ( Some ( monitor ) ) = self . current_monitor ( ) {
// save only window positions that are inside the current monitor
if monitor . contains ( position ) & & ! is_maximized {
state . x = position . x ;
state . y = position . y ;
}
}
} }
Ok ( ( ) ) Ok ( ( ) )
@ -156,17 +241,15 @@ impl<R: Runtime> WindowExt for Window<R> {
#[ derive(Default) ] #[ derive(Default) ]
pub struct Builder { pub struct Builder {
show_mode : ShowMode ,
denylist : HashSet < String > , denylist : HashSet < String > ,
skip_initial_state : HashSet < String > , skip_initial_state : HashSet < String > ,
state_flags : StateFlags ,
} }
impl Builder { impl Builder {
/// Sets how the window visibility should be restored.
/// Sets the state flags to control what state gets restored and saved.
///
pub fn with_state_flags ( mut self , flags : StateFlags ) -> Self {
/// The default is [`ShowMode::LastSaved`]
self . state_flags = flags ;
pub fn with_show_mode ( mut self , show_mode : ShowMode ) -> Self {
self . show_mode = show_mode ;
self self
} }
@ -184,9 +267,10 @@ impl Builder {
} }
pub fn build < R : Runtime > ( self ) -> TauriPlugin < R > { pub fn build < R : Runtime > ( self ) -> TauriPlugin < R > {
let flags = self . state_flags ;
PluginBuilder ::new ( "window-state" ) PluginBuilder ::new ( "window-state" )
. setup ( | app | { . setup ( | app | {
let cache : Arc < Mutex < HashMap < String , Window Metadata > > > = if let Some ( app_dir ) = let cache : Arc < Mutex < HashMap < String , Window State > > > = if let Some ( app_dir ) =
app . path_resolver ( ) . app_config_dir ( ) app . path_resolver ( ) . app_config_dir ( )
{ {
let state_path = app_dir . join ( STATE_FILENAME ) ; let state_path = app_dir . join ( STATE_FILENAME ) ;
@ -212,67 +296,26 @@ impl Builder {
} }
if ! self . skip_initial_state . contains ( window . label ( ) ) { if ! self . skip_initial_state . contains ( window . label ( ) ) {
let _ = window . restore_state ( self . s how_mode ) ; let _ = window . restore_state ( self . s tate_flags ) ;
} }
let cache = window . state ::< WindowStateCache > ( ) ; let cache = window . state ::< WindowStateCache > ( ) ;
let cache = cache . 0. clone ( ) ; let cache = cache . 0. clone ( ) ;
let label = window . label ( ) . to_string ( ) ; let label = window . label ( ) . to_string ( ) ;
let window_clone = window . clone ( ) ; let window_clone = window . clone ( ) ;
window . on_window_event ( move | e | match e { let flags = self . state_flags ;
WindowEvent ::Moved ( position ) = > { window . on_window_event ( move | e | {
let mut c = cache . lock ( ) . unwrap ( ) ; if let WindowEvent ::CloseRequested { .. } = e {
if let Some ( state ) = c . get_mut ( & label ) {
let is_maximized = window_clone . is_maximized ( ) . unwrap_or ( false ) ;
state . maximized = is_maximized ;
if let Some ( monitor ) = window_clone . current_monitor ( ) . unwrap ( ) {
let monitor_position = monitor . position ( ) ;
// save only window positions that are inside the current monitor
if position . x > monitor_position . x
& & position . y > monitor_position . y
& & ! is_maximized
{
state . x = position . x ;
state . y = position . y ;
} ;
} ;
}
}
WindowEvent ::Resized ( size ) = > {
let scale_factor = window_clone
. current_monitor ( )
. ok ( )
. map ( | m | m . map ( | m | m . scale_factor ( ) ) . unwrap_or ( 1. ) )
. unwrap_or ( 1. ) ;
let size = size . to_logical ( scale_factor ) ;
let mut c = cache . lock ( ) . unwrap ( ) ;
if let Some ( state ) = c . get_mut ( & label ) {
let is_maximized = window_clone . is_maximized ( ) . unwrap_or ( false ) ;
let is_fullscreen = window_clone . is_fullscreen ( ) . unwrap_or ( false ) ;
state . decorated = window_clone . is_decorated ( ) . unwrap_or ( true ) ;
state . maximized = is_maximized ;
state . fullscreen = is_fullscreen ;
// It doesn't make sense to save a window with 0 height or width
if size . width > 0. & & size . height > 0. & & ! is_maximized {
state . width = size . width ;
state . height = size . height ;
}
}
}
WindowEvent ::CloseRequested { .. } = > {
let mut c = cache . lock ( ) . unwrap ( ) ; let mut c = cache . lock ( ) . unwrap ( ) ;
if let Some ( state ) = c . get_mut ( & label ) { if let Some ( state ) = c . get_mut ( & label ) {
state . visible = window_clone . is_visible ( ) . unwrap_or ( true ) ; let _ = window_clone . update_state ( state , flags ) ;
} }
} }
_ = > { }
} ) ; } ) ;
} ) } )
. on_event ( | app , event | { . on_event ( move | app , event | {
if let RunEvent ::Exit = event { if let RunEvent ::Exit = event {
let _ = app . save_window_state ( ) ; let _ = app . save_window_state ( flags ) ;
} }
} ) } )
. build ( ) . build ( )
FabianLars
2 years ago