zng_ext_window/

vars.rs

use core::fmt;
use std::sync::{Arc, atomic::AtomicBool};

use crate::{AutoSize, CursorSource, MonitorQuery, WindowIcon, WindowInstanceState};
use zng_app::{
    widget::{WidgetId, base::Parallel, info::access::AccessEnabled},
    window::{MonitorId, WINDOW, WindowId},
};
use zng_color::LightDark;
use zng_layout::unit::{
    Dip, DipPoint, DipRect, DipSideOffsets, DipSize, DipToPx, Factor, FactorUnits, Frequency, FrequencyUnits as _, Length, LengthUnits,
    Point, PxPoint, PxSize, Size,
};
use zng_state_map::{StateId, static_id};
use zng_txt::Txt;
use zng_unique_id::IdSet;
use zng_var::{Var, VarValue, merge_var, var, var_from};
use zng_view_api::{
    config::{ColorScheme, ColorsConfig},
    window::{CursorIcon, FocusIndicator, RenderMode, VideoMode, WindowState, WindowStateAll},
};

#[cfg(feature = "image")]
use crate::FrameCaptureMode;
#[cfg(feature = "image")]
use zng_ext_image::ImageEntry;

pub(crate) struct WindowVarsData {
    pub(crate) instance_state: Var<WindowInstanceState>,

    pub(crate) chrome: Var<bool>,
    pub(crate) icon: Var<WindowIcon>,
    #[cfg(feature = "image")]
    pub(crate) actual_icon: Var<Option<ImageEntry>>,
    pub(crate) cursor: Var<CursorSource>,
    #[cfg(feature = "image")]
    pub(crate) actual_cursor_img: Var<Option<(ImageEntry, PxPoint)>>,
    pub(crate) title: Var<Txt>,

    pub(crate) state: Var<WindowState>,
    pub(crate) focus_indicator: Var<Option<FocusIndicator>>,

    pub(crate) position: Var<Point>,
    pub(crate) monitor: Var<MonitorQuery>,
    pub(crate) video_mode: Var<VideoMode>,

    pub(crate) size: Var<Size>,
    pub(crate) auto_size: Var<AutoSize>,
    pub(crate) auto_size_origin: Var<Point>,
    pub(crate) min_size: Var<Size>,
    pub(crate) max_size: Var<Size>,

    pub(crate) font_size: Var<Length>,

    pub(crate) actual_position: Var<DipPoint>,
    pub(crate) global_position: Var<PxPoint>,
    pub(crate) actual_monitor: Var<Option<MonitorId>>,
    pub(crate) actual_size: Var<DipSize>,
    pub(crate) actual_min_size: Var<DipSize>,
    pub(crate) actual_max_size: Var<DipSize>,
    pub(crate) safe_padding: Var<DipSideOffsets>,

    pub(crate) scale_factor: Var<Factor>,
    pub(crate) refresh_rate: Var<Frequency>,

    pub(crate) restore_state: Var<WindowState>,
    pub(crate) restore_state_fullscreen: Var<Option<WindowState>>,
    pub(crate) restore_rect: Var<DipRect>,

    pub(crate) can_minimize: Var<bool>,
    pub(crate) can_maximize: Var<bool>,
    pub(crate) can_fullscreen: Var<bool>,
    pub(crate) can_close: Var<bool>,

    pub(crate) resizable: Var<bool>,
    pub(crate) movable: Var<bool>,

    pub(crate) always_on_top: Var<bool>,

    pub(crate) visible: Var<bool>,
    pub(crate) taskbar_visible: Var<bool>,

    pub(crate) parent: Var<Option<WindowId>>,
    pub(crate) nest_parent: Var<Option<WidgetId>>,
    modal: Var<bool>,
    pub(crate) children: Var<IdSet<WindowId>>,

    pub(crate) color_scheme: Var<Option<ColorScheme>>,
    pub(crate) actual_color_scheme: Var<ColorScheme>,
    pub(crate) accent_color: Var<Option<LightDark>>,
    pub(crate) actual_accent_color: Var<LightDark>,

    pub(crate) focused: Var<bool>,

    #[cfg(feature = "image")]
    pub(crate) frame_capture_mode: Var<FrameCaptureMode>,
    pub(crate) render_mode: Var<RenderMode>,

    pub(crate) access_enabled: Var<AccessEnabled>,
    pub(crate) system_shutdown_warn: Var<Txt>,

    parallel: Var<Parallel>,

    pub(crate) pending_state_update: AtomicBool,
}

/// Variables that configure the opening or open window.
///
/// You can get the vars for any window using [`WINDOWS.vars`].
///
/// You can get the vars for the current context window using [`WINDOW.vars`].
///
/// [`WINDOWS.vars`]: crate::WINDOWS::vars
/// [`WINDOW.vars`]: crate::WINDOW_Ext::vars
#[derive(Clone)]
pub struct WindowVars(pub(crate) Arc<WindowVarsData>);
impl fmt::Debug for WindowVars {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_tuple("WindowVars").finish_non_exhaustive()
    }
}
impl WindowVars {
    pub(crate) fn new(default_render_mode: RenderMode, primary_scale_factor: Factor, system_colors: ColorsConfig) -> Self {
        let vars = Arc::new(WindowVarsData {
            instance_state: var(WindowInstanceState::Building),
            chrome: var(true),
            icon: var(WindowIcon::Default),
            #[cfg(feature = "image")]
            actual_icon: var(None),
            cursor: var_from(CursorIcon::Default),
            #[cfg(feature = "image")]
            actual_cursor_img: var(None),
            title: var(zng_env::about().app.clone()),

            state: var(WindowState::Normal),
            focus_indicator: var(None),

            position: var(Point::default()),
            monitor: var(MonitorQuery::default()),
            video_mode: var(VideoMode::default()),
            size: var(Size::default()),

            font_size: var(11.pt()),

            actual_position: var(DipPoint::zero()),
            global_position: var(PxPoint::zero()),
            actual_monitor: var(None),
            actual_size: var(DipSize::zero()),
            actual_min_size: var(DipSize::zero()),
            actual_max_size: var(DipSize::splat(Dip::MAX)),
            safe_padding: var(DipSideOffsets::zero()),

            scale_factor: var(primary_scale_factor),
            refresh_rate: var(60.hertz()),

            restore_state: var(WindowState::Normal),
            restore_state_fullscreen: var(None),
            restore_rect: var(DipRect::new(
                DipPoint::new(Dip::new(30), Dip::new(30)),
                DipSize::new(Dip::new(800), Dip::new(600)),
            )),

            can_minimize: var(true),
            can_maximize: var(true),
            can_fullscreen: var(true),
            can_close: var(true),

            min_size: var(Size::new(192, 48)),
            max_size: var(Size::new(100.pct(), 100.pct())),

            auto_size: var(AutoSize::empty()),
            auto_size_origin: var(Point::top_left()),

            resizable: var(true),
            movable: var(true),

            always_on_top: var(false),

            visible: var(true),
            taskbar_visible: var(true),

            parent: var(None),
            nest_parent: var(None),
            modal: var(false),
            children: var(IdSet::default()),

            color_scheme: var(None),
            actual_color_scheme: var(system_colors.scheme),
            accent_color: var(None),
            actual_accent_color: var(system_colors.accent.into()),

            focused: var(false),

            #[cfg(feature = "image")]
            frame_capture_mode: var(FrameCaptureMode::Sporadic),
            render_mode: var(default_render_mode),

            access_enabled: var(AccessEnabled::empty()),
            system_shutdown_warn: var(Txt::from("")),

            parallel: var(Parallel::default()),

            pending_state_update: AtomicBool::new(false),
        });
        Self(vars)
    }

    /// Require the window vars from the window state.
    ///
    /// # Panics
    ///
    /// Panics if called in a custom window context that did not setup the variables.
    pub(crate) fn req() -> Self {
        WINDOW.req_state(*WINDOW_VARS_ID)
    }

    /// Window instance state.
    pub fn instance_state(&self) -> Var<WindowInstanceState> {
        self.0.instance_state.read_only()
    }

    /// Defines if the window chrome is visible.
    ///
    /// The window chrome is the non-client area of the window, usually a border with resize handles and a title bar.
    ///
    /// The default value is `true`.
    ///
    /// Note that if the [`WINDOWS.system_chrome`] reports the windowing system prefers a custom chrome **and** does not
    /// provide one the system chrome is not requested, even if this is `true`. Window widget implementers can use that variable to
    /// detect when a fallback chrome must be provided.
    ///
    /// [`WINDOWS.system_chrome`]: crate::WINDOWS::system_chrome
    pub fn chrome(&self) -> Var<bool> {
        self.0.chrome.clone()
    }

    /// Window icon.
    ///
    /// See [`WindowIcon`] for details.
    ///
    /// The default value is [`WindowIcon::Default`].
    ///
    /// You can retrieve the custom icon image using [`actual_icon`].
    ///
    /// [`actual_icon`]: Self::actual_icon
    pub fn icon(&self) -> Var<WindowIcon> {
        self.0.icon.clone()
    }

    /// Window icon image.
    ///
    /// This is `None` if [`icon`] is [`WindowIcon::Default`], otherwise it is an [`ImageEntry`]
    /// reference clone.
    ///
    /// [`icon`]: Self::icon
    /// [`ImageEntry`]: zng_ext_image::ImageEntry
    #[cfg(feature = "image")]
    pub fn actual_icon(&self) -> Var<Option<ImageEntry>> {
        self.0.actual_icon.read_only()
    }

    /// Window cursor icon and visibility.
    ///
    /// See [`CursorSource`] for details.
    ///
    /// The default is [`CursorIcon::Default`].
    ///
    /// [`CursorIcon`]: zng_view_api::window::CursorIcon
    /// [`CursorIcon::Default`]: zng_view_api::window::CursorIcon::Default
    pub fn cursor(&self) -> Var<CursorSource> {
        self.0.cursor.clone()
    }

    /// Window custom cursor image.
    ///
    /// This is `None` if [`cursor`] is not set to a custom image, otherwise it is an [`ImageEntry`]
    /// reference clone with computed hotspot [`PxPoint`].
    ///
    /// [`cursor`]: Self::cursor
    /// [`ImageEntry`]: zng_ext_image::ImageEntry
    /// [`PxPoint`]: zng_layout::unit::PxPoint
    #[cfg(feature = "image")]
    pub fn actual_cursor_img(&self) -> Var<Option<(ImageEntry, PxPoint)>> {
        self.0.actual_cursor_img.read_only()
    }

    /// Window title text.
    ///
    /// The default value is `""`.
    pub fn title(&self) -> Var<Txt> {
        self.0.title.clone()
    }

    /// Window screen state.
    ///
    /// Minimized, maximized or fullscreen. See [`WindowState`] for details.
    ///
    /// The default value is [`WindowState::Normal`].
    pub fn state(&self) -> Var<WindowState> {
        self.0.state.clone()
    }

    /// Window monitor.
    ///
    /// The query selects the monitor to which the [`position`] and [`size`] is relative to.
    ///
    /// It evaluate once when the window opens and then once every time the variable updates. You can track
    /// what the current monitor is by using [`actual_monitor`].
    ///
    /// # Behavior After Open
    ///
    /// If this variable is changed after the window has opened, and the new query produces a different
    /// monitor from the [`actual_monitor`] and the window is visible; then the window is moved to
    /// the new monitor:
    ///
    /// * **Maximized**: The window is maximized in the new monitor.
    /// * **Fullscreen**: The window is fullscreen in the new monitor.
    /// * **Normal**: The window is centered in the new monitor, keeping the same size.
    /// * **Minimized/Hidden**: The window remains hidden, the restore position and size are defined like **Normal**.
    ///
    /// [`position`]: WindowVars::position
    /// [`actual_monitor`]: WindowVars::actual_monitor
    /// [`size`]: WindowVars::size
    pub fn monitor(&self) -> Var<MonitorQuery> {
        self.0.monitor.clone()
    }

    /// Video mode for exclusive fullscreen.
    pub fn video_mode(&self) -> Var<VideoMode> {
        self.0.video_mode.clone()
    }

    /// Current monitor hosting the window.
    ///
    /// This is `None` if the window has not opened yet (before first render) or if
    /// no monitors where found in the operating system or if the window is headless without renderer.
    pub fn actual_monitor(&self) -> Var<Option<MonitorId>> {
        self.0.actual_monitor.read_only()
    }

    /// Available video modes in the current monitor.
    pub fn video_modes(&self) -> Var<Vec<VideoMode>> {
        self.0.actual_monitor.flat_map(|&m| {
            m.and_then(|m| super::MONITORS.monitor(m))
                .unwrap_or_else(super::MonitorInfo::fallback)
                .video_modes()
        })
    }

    /// Current scale factor of the current monitor hosting the window.
    ///
    /// Note that this is only set after [`actual_monitor`] is set. During layout prefer [`LAYOUT.scale_factor`] as
    /// it will already be set to the scale factor of the expected monitor when the window is still opening.
    ///
    /// [`actual_monitor`]: Self::actual_monitor
    /// [`LAYOUT.scale_factor`]: zng_wgt::prelude::LAYOUT::scale_factor
    pub fn scale_factor(&self) -> Var<Factor> {
        self.0.scale_factor.read_only()
    }

    /// Window actual position on the [monitor].
    ///
    /// This is a read-only variable that tracks the computed position of the window, it updates every
    /// time the window moves.
    ///
    /// The initial value is `(0, 0)`, it starts updating once the window opens. The point
    /// is relative to the origin of the [monitor].
    ///
    /// [monitor]: Self::actual_monitor
    pub fn actual_position(&self) -> Var<DipPoint> {
        self.0.actual_position.read_only()
    }

    /// Window actual position on the virtual screen that encompasses all monitors.
    ///
    /// This is a read-only variable that tracks the computed position of the window, it updates every
    /// time the window moves.
    ///
    /// The initial value is `(0, 0)`, it starts updating once the window opens.
    pub fn global_position(&self) -> Var<PxPoint> {
        self.0.global_position.read_only()
    }

    /// Window restore state.
    ///
    /// Defines the state the window will return to when restored from [`Maximized`] or [`Minimized`].
    ///
    /// * If the [current state] is [`Maximized`], this is [`Normal`].
    /// * If the [current state] is [`Minimized`], this is the pre-minimization state.
    /// * If the [current state] is [`Fullscreen`] or [`Exclusive`], this retains the previous
    ///   non-fullscreen state (e.g., [`Maximized`] or [`Normal`]) to restore to when exiting fullscreen.
    ///
    /// When this resolves to [`Normal`], the [`restore_rect`] defines the window's position and size.
    ///
    /// Note that if a fullscreen window is minimized, [`restore_state_fullscreen`] is set and will
    /// take precedence over this value upon restoration.
    ///
    /// [current state]: Self::state
    /// [`Maximized`]: WindowState::Maximized
    /// [`Fullscreen`]: WindowState::Fullscreen
    /// [`Exclusive`]: WindowState::Exclusive
    /// [`Normal`]: WindowState::Normal
    /// [`Minimized`]: WindowState::Minimized
    /// [`restore_rect`]: Self::restore_rect
    /// [`restore_state_fullscreen`]: Self::restore_state_fullscreen
    pub fn restore_state(&self) -> Var<WindowState> {
        self.0.restore_state.read_only()
    }

    /// Fullscreen restore state from minimized.
    ///
    /// Stores the fullscreen mode if the window was minimized while in [`Fullscreen`]
    /// or [`Exclusive`].
    ///
    /// When this is `Some` and the window exits [`Minimized`], it restores directly back to
    /// this fullscreen mode instead of [`restore_state`]. This variable resets to `None` once the window is restored.
    ///
    /// [`restore_state`]: Self::restore_state
    /// [`Fullscreen`]: WindowState::Fullscreen
    /// [`Exclusive`]: WindowState::Exclusive
    /// [`Minimized`]: WindowState::Minimized
    pub fn restore_state_fullscreen(&self) -> Var<Option<WindowState>> {
        self.0.restore_state_fullscreen.read_only()
    }

    /// Window restore position and size when restoring to [`Normal`].
    ///
    /// The restore rectangle is the window position and size when its state is [`Normal`], when the state is not [`Normal`]
    /// this variable tracks the last normal position and size, it will be the window [`actual_position`] and [`actual_size`] again
    /// when the state is set back to [`Normal`].
    ///
    /// This is a read-only variable, to programmatically set it assign the [`position`] and [`size`] variables. The initial
    /// value is `(30, 30).at(800, 600)`, it starts updating when the window opens.
    ///
    /// Note that to restore the window you only need to set [`state`] to [`restore_state`], if the restore state is [`Normal`]
    /// this position and size will be applied automatically.
    ///
    /// [`Normal`]: WindowState::Normal
    /// [`actual_position`]: Self::actual_position
    /// [`actual_size`]: Self::actual_size
    /// [`position`]: Self::position
    /// [`size`]: Self::size
    /// [`monitor`]: Self::monitor
    /// [`actual_monitor`]: Self::actual_monitor
    /// [`state`]: Self::state
    /// [`restore_state`]: Self::restore_state
    pub fn restore_rect(&self) -> Var<DipRect> {
        self.0.restore_rect.read_only()
    }

    /// Window top-left offset on the [`monitor`] when the window is [`Normal`].
    ///
    /// Relative values are computed in relation to the [`monitor`] size, updating every time the
    /// position or monitor variable updates.
    ///
    /// When the user moves the window this value is considered stale, when it updates it overwrites the window position again,
    /// note that the window is only moved if it is in the [`Normal`] state, otherwise only the [`restore_rect`] updates.
    ///
    /// When the window is moved by the user this variable does **not** update back, to track the current position of the window
    /// use [`actual_position`], to track the restore position use [`restore_rect`].
    ///
    /// The [`Length::Default`] value causes the OS to select a value.
    ///
    /// [`restore_rect`]: WindowVars::restore_rect
    /// [`actual_position`]: WindowVars::actual_position
    /// [`monitor`]: WindowVars::monitor
    /// [`Normal`]: WindowState::Normal
    /// [`Length::Default`]: zng_layout::unit::Length::Default
    pub fn position(&self) -> Var<Point> {
        self.0.position.clone()
    }

    /// Window actual size on the screen.
    ///
    /// This is a read-only variable that tracks the computed size of the window, it updates every time
    /// the window resizes.
    ///
    /// The initial value is `(0, 0)`, it starts updating when the window opens.
    pub fn actual_size(&self) -> Var<DipSize> {
        self.0.actual_size.read_only()
    }

    /// Window [`actual_size`], converted to pixels given the [`scale_factor`].
    ///
    /// [`actual_size`]: Self::actual_size
    /// [`scale_factor`]: Self::scale_factor
    pub fn actual_size_px(&self) -> Var<PxSize> {
        merge_var!(self.0.actual_size.clone(), self.0.scale_factor.clone(), |size, factor| {
            PxSize::new(size.width.to_px(*factor), size.height.to_px(*factor))
        })
    }

    /// Window actual min size.
    ///
    /// This is a read-only variable that tracks the computed min size of the window.
    pub fn actual_min_size(&self) -> Var<DipSize> {
        self.0.actual_min_size.read_only()
    }

    /// Window actual max size.
    ///
    /// This is a read-only variable that tracks the computed min size of the window.
    pub fn actual_max_size(&self) -> Var<DipSize> {
        self.0.actual_max_size.read_only()
    }

    /// Padding that must be applied to the window content so that it stays clear of screen obstructions
    /// such as a camera notch cutout.
    ///
    /// Note that the *unsafe* area must still be rendered as it may be partially visible, just don't place nay
    /// interactive or important content outside of this padding.
    pub fn safe_padding(&self) -> Var<DipSideOffsets> {
        self.0.safe_padding.read_only()
    }

    /// Window width and height on the screen when the window is [`Normal`].
    ///
    /// Relative values are computed in relation to the [`monitor`] size, updating every time the
    /// size or monitor variable updates.
    ///
    /// When the user resizes the window this value is considered stale, when it updates it overwrites the window size again,
    /// note that the window is only resized if it is in the [`Normal`] state, otherwise only the [`restore_rect`] updates.
    ///
    /// When the window is resized this variable is **not** updated back, to track the current window size use [`actual_size`],
    /// to track the restore size use [`restore_rect`].
    ///
    /// The default value is `(800, 600)`.
    ///
    /// [`actual_size`]: WindowVars::actual_size
    /// [`monitor`]: WindowVars::monitor
    /// [`restore_rect`]: WindowVars::restore_rect
    /// [`Normal`]: WindowState::Normal
    pub fn size(&self) -> Var<Size> {
        self.0.size.clone()
    }

    /// Defines if and how the window size is controlled by the content layout.
    ///
    /// When enabled overwrites previously set window size, but is still coerced by [`min_size`]
    /// and [`max_size`]. Auto-size is disabled if the user resizes the window or if [`size`]
    /// is set.
    ///
    /// The default value is [`AutoSize::DISABLED`].
    ///
    /// [`size`]: Self::size
    /// [`min_size`]: Self::min_size
    /// [`max_size`]: Self::max_size
    pub fn auto_size(&self) -> Var<AutoSize> {
        self.0.auto_size.clone()
    }

    /// The point in the window content that does not move when the window is resized by [`auto_size`].
    ///
    /// When the window size increases it *grows* to the right-bottom, the top-left corner does not move because
    /// the origin of windows it at the top-left and the position did not change, this variables overwrites this origin
    /// for [`auto_size`] size changes, the window position is adjusted so that it is the center of the resize.
    ///
    /// Note this only applies to resizes, the initial auto-size when the window opens is positioned according to the [`StartPosition`] value.
    ///
    /// The default value is [`Point::top_left`].
    ///
    /// [`auto_size`]: Self::auto_size
    /// [`monitor`]: WindowVars::monitor
    /// [`StartPosition`]: crate::StartPosition
    /// [`Point::top_left`]: zng_layout::unit::Point::top_left
    pub fn auto_size_origin(&self) -> Var<Point> {
        self.0.auto_size_origin.clone()
    }

    /// Minimal window width and height constraint on the [`size`].
    ///
    /// Relative values are computed in relation to the [`monitor`] size, updating every time the
    /// size or monitor variable updates.
    ///
    /// Note that the OS can also define a minimum size that supersedes this variable.
    ///
    /// The default value is `(192, 48)`.
    ///
    /// [`monitor`]: WindowVars::monitor
    /// [`size`]: Self::size
    pub fn min_size(&self) -> Var<Size> {
        self.0.min_size.clone()
    }

    /// Maximal window width and height constraint on the [`size`].
    ///
    /// Relative values are computed in relation to the [`monitor`] size, updating every time the
    /// size or monitor variable updates.
    ///
    /// Note that the OS can also define a maximum size that supersedes this variable.
    ///
    /// The default value is `(100.pct(), 100.pct())`
    ///
    /// [`monitor`]: WindowVars::monitor
    /// [`size`]: Self::size
    pub fn max_size(&self) -> Var<Size> {
        self.0.max_size.clone()
    }

    /// Root font size.
    ///
    /// This is the font size in all widget branches  that do not override the font size. The [`rem`] unit is relative to this value.
    ///
    /// [`rem`]: LengthUnits::rem
    pub fn font_size(&self) -> Var<Length> {
        self.0.font_size.clone()
    }

    /// Defines if the user can resize the window using the window frame.
    ///
    /// Note that even if disabled the window can still be resized from other sources.
    ///
    /// The default value is `true`.
    pub fn resizable(&self) -> Var<bool> {
        self.0.resizable.clone()
    }

    /// Defines if the user can move the window using the window frame.
    ///
    /// Note that even if disabled the window can still be moved from other sources.
    ///
    /// The default value is `true`.
    pub fn movable(&self) -> Var<bool> {
        self.0.movable.clone()
    }

    /// Defines if the user can minimize the window.
    ///
    /// Note that even if disabled the window can still be minimized by setting the state directly.
    ///
    /// The default value is `true`.
    pub fn can_minimize(&self) -> Var<bool> {
        self.0.can_minimize.clone()
    }

    /// Defines if the user can maximize/restore the window.
    ///
    /// Note that even if disabled the window can still be maximized by setting the state directly.
    ///
    /// The default value is `true`.
    pub fn can_maximize(&self) -> Var<bool> {
        self.0.can_maximize.clone()
    }

    /// Defines if the user can toggle fullscreen the window.
    ///
    /// Note that even if disabled the window can still enter fullscreen by setting the state directly.
    ///
    /// The default value is `true`.
    pub fn can_fullscreen(&self) -> Var<bool> {
        self.0.can_fullscreen.clone()
    }

    /// Defines if the user can request close the window.
    ///
    /// Note that even if disabled the window can still be closed directly.
    ///
    /// The default value is `true`.
    pub fn can_close(&self) -> Var<bool> {
        self.0.can_close.clone()
    }

    /// Defines if the window should always stay on top of other windows.
    ///
    /// Note this only applies to other windows that are not also "always-on-top".
    ///
    /// The default value is `false`.
    pub fn always_on_top(&self) -> Var<bool> {
        self.0.always_on_top.clone()
    }

    /// Defines if the window is visible on the screen and in the task-bar.
    ///
    /// This variable is observed only after the first frame render, before that the window
    /// is always not visible.
    ///
    /// The default value is `true`.
    pub fn visible(&self) -> Var<bool> {
        self.0.visible.clone()
    }

    /// Defines if the window is visible in the task-bar.
    ///
    /// The default value is `true`.
    pub fn taskbar_visible(&self) -> Var<bool> {
        self.0.taskbar_visible.clone()
    }

    /// Defines the parent window.
    ///
    /// If a parent is set this behavior applies:
    ///
    /// * If the parent is minimized, this window is also minimized.
    /// * If the parent window is maximized, this window is restored.
    /// * This window is always on-top of the parent window.
    /// * If the parent window is closed, this window is also closed.
    /// * If [`modal`] is set, the parent window cannot be focused while this window is open.
    /// * If a [`color_scheme`] is not set, the fallback is the parent's actual scheme.
    /// * If an [`accent_color`] is not set, the fallback is the parent's actual accent.
    ///
    /// The default value is `None`.
    ///
    /// # Validation
    ///
    /// The parent window cannot have a parent, if it has, that parent ID is used instead.
    /// The parent window must exist. This window (child) cannot have children, it also can't set itself as the parent.
    ///
    /// If any of these conditions are not met, an error is logged and the parent var is restored to the previous value.
    ///
    /// [`modal`]: Self::modal
    /// [`color_scheme`]: Self::color_scheme
    /// [`accent_color`]: Self::accent_color
    pub fn parent(&self) -> Var<Option<WindowId>> {
        self.0.parent.clone()
    }

    /// Gets the widget in [`parent`] that hosts the window, if it is nesting.
    ///
    /// Nesting windows are presented as an widget, similar to an "iframe".
    ///
    /// [`parent`]: Self::parent
    pub fn nest_parent(&self) -> Var<Option<WidgetId>> {
        self.0.nest_parent.read_only()
    }

    /// Defines the [`parent`](Self::parent) connection.
    ///
    /// Value is ignored if `parent` is not set. When this is `true` the parent window cannot be focused while this window is open.
    ///
    /// The default value is `false`.
    pub fn modal(&self) -> Var<bool> {
        self.0.modal.clone()
    }

    /// Window children.
    ///
    /// This is a set of other windows that have this window as a [`parent`].
    ///
    /// [`parent`]: Self::parent
    pub fn children(&self) -> Var<IdSet<WindowId>> {
        self.0.children.read_only()
    }

    /// Override the preferred color scheme.
    ///
    /// If set to `None` the system preference is used, see [`actual_color_scheme`].
    ///
    /// [`actual_color_scheme`]: Self::actual_color_scheme
    pub fn color_scheme(&self) -> Var<Option<ColorScheme>> {
        self.0.color_scheme.clone()
    }

    /// Actual color scheme to use.
    ///
    /// This is the system preference, or [`color_scheme`] if it is set.
    ///
    /// [`color_scheme`]: Self::color_scheme
    pub fn actual_color_scheme(&self) -> Var<ColorScheme> {
        self.0.actual_color_scheme.read_only()
    }

    /// Override the preferred accent color.
    ///
    /// If set to `None` the system preference is used, see [`actual_accent_color`].
    ///
    /// [`actual_accent_color`]: Self::actual_accent_color
    pub fn accent_color(&self) -> Var<Option<LightDark>> {
        self.0.accent_color.clone()
    }

    /// Actual accent color to use.
    ///
    /// This is the system preference, or [`color_scheme`] if it is set.
    ///
    /// The window widget also sets [`ACCENT_COLOR_VAR`] to this variable.
    ///
    /// [`color_scheme`]: Self::color_scheme
    /// [`ACCENT_COLOR_VAR`]: zng_color::colors::ACCENT_COLOR_VAR
    pub fn actual_accent_color(&self) -> Var<LightDark> {
        self.0.actual_accent_color.read_only()
    }

    /// Read-only variable that tracks if the window is focused in the system window manager.
    ///
    /// Note that most of the time its preferable to use the `FOCUS` service as it also tracks the widget focus.
    pub fn is_focused(&self) -> Var<bool> {
        self.0.focused.read_only()
    }

    /// Defines the active user attention required indicator.
    ///
    /// This is usually a visual indication on the taskbar icon that prompts the user to focus on the window, it is automatically
    /// changed to `None` once the window receives focus or you can set it to `None` to cancel the indicator.
    ///
    /// Prefer using the `FOCUS` service and advanced `FocusRequest` configs instead of setting this variable directly.
    pub fn focus_indicator(&self) -> Var<Option<FocusIndicator>> {
        self.0.focus_indicator.clone()
    }

    /// Defines if and how the frame pixels are captured for the next rendered frames.
    ///
    /// If set to [`Next`] the value will change to [`Sporadic`] after the next frame is rendered.
    ///
    /// Note that setting this to [`Next`] does not cause a frame request. Use [`WIDGET.render_update`] for that.
    ///
    /// [`Next`]: FrameCaptureMode::Next
    /// [`Sporadic`]: FrameCaptureMode::Sporadic
    /// [`WIDGET.render_update`]: zng_app::widget::WIDGET::render_update
    #[cfg(feature = "image")]
    pub fn frame_capture_mode(&self) -> Var<FrameCaptureMode> {
        self.0.frame_capture_mode.clone()
    }

    /// Window actual render mode.
    ///
    /// The initial value is the [`default_render_mode`], it can update after the window is created, when the view-process
    /// actually creates the backend window and after a view-process respawn.
    ///
    /// [`default_render_mode`]: crate::WINDOWS::default_render_mode
    pub fn render_mode(&self) -> Var<RenderMode> {
        self.0.render_mode.read_only()
    }

    /// If an accessibility service has requested info from this window.
    ///
    /// You can enable this in the app-process using [`enable_access`], the
    /// view-process can also enable it on the first request for accessibility info by an external tool.
    ///
    /// This variable does not update to fully disabled after first enable, but the VIEW bit can disable and re-enable.
    ///
    /// [`enable_access`]: crate::WINDOW_Ext::enable_access
    pub fn access_enabled(&self) -> Var<AccessEnabled> {
        self.0.access_enabled.read_only()
    }

    /// Attempt to set a system wide shutdown warning associated with the window.
    ///
    /// Operating systems that support this show the text in a warning for the user, it must be a short text
    /// that identifies the critical operation that cannot be cancelled.
    ///
    /// Set to an empty text to remove the warning.
    ///
    /// Note that this does not stop the window from closing or the app from exiting normally, you must
    /// handle window close requests and show some feedback to the user, the view-process will send a window close
    /// request when a system shutdown attempt is detected.
    ///
    /// Note that there is no guarantee that the view-process or operating system will actually set a block, there
    /// is no error result because operating systems can silently ignore block requests at any moment, even after
    /// an initial successful block.
    ///
    /// ## Current Limitations
    ///
    /// The current `zng::view_process` or `zng-view` only implements this feature on Windows and it will only work properly
    /// under these conditions:
    ///
    /// * It must be running in `run_same_process` mode. Windows kills all other processes, so in a run with `init` the app-process
    ///   will be lost. Note that this also mean that the crash handler and worker processes are also killed.
    /// * Must be built with `#![windows_subsystem = "windows"]` and must be running from the Windows Explorer (desktop).
    pub fn system_shutdown_warn(&self) -> Var<Txt> {
        self.0.system_shutdown_warn.clone()
    }

    /// Defines what node list methods can run in parallel in the window widgets.
    ///
    /// The window binds [`PARALLEL_VAR`] to this value at the root node ensuring all window nodes are
    /// configured.
    ///
    /// See also [`WINDOWS.parallel`] to define parallelization between windows.
    ///
    /// [`PARALLEL_VAR`]: zng_app::widget::base::PARALLEL_VAR
    /// [`WINDOWS.parallel`]: crate::WINDOWS::parallel
    pub fn parallel(&self) -> Var<Parallel> {
        self.0.parallel.clone()
    }

    #[cfg(feature = "image")]
    pub(crate) fn take_frame_capture(&self) -> zng_view_api::window::FrameCapture {
        use zng_view_api::window::FrameCapture;
        match self.0.frame_capture_mode.get() {
            FrameCaptureMode::Sporadic => FrameCapture::None,
            FrameCaptureMode::Next => {
                self.0.frame_capture_mode.set(FrameCaptureMode::Sporadic);
                FrameCapture::Full
            }
            FrameCaptureMode::All => FrameCapture::Full,
            FrameCaptureMode::NextMask(m) => {
                self.0.frame_capture_mode.set(FrameCaptureMode::Sporadic);
                FrameCapture::Mask(m)
            }
            FrameCaptureMode::AllMask(m) => FrameCapture::Mask(m),
        }
    }
    #[cfg(not(feature = "image"))]
    pub(crate) fn take_frame_capture(&self) -> zng_view_api::window::FrameCapture {
        zng_view_api::window::FrameCapture::None
    }

    pub(crate) fn window_state_all(&self) -> WindowStateAll {
        WindowStateAll::new(
            self.0.state.get(),
            self.0.global_position.get(),
            self.0.restore_rect.get(),
            self.0.restore_state.get(),
            self.0.restore_state_fullscreen.get(),
            self.0.actual_min_size.get(),
            self.0.actual_max_size.get(),
            self.0.chrome.get(),
        )
    }

    pub(crate) fn set_from_view<T: VarValue>(&self, var: impl FnOnce(&Self) -> &Var<T>, new_value: T) {
        var(self).modify(move |a| {
            if a.set(new_value) {
                a.push_tag(SetFromViewTag);
            }
        });
    }
}
impl PartialEq for WindowVars {
    fn eq(&self, other: &Self) -> bool {
        Arc::ptr_eq(&self.0, &other.0)
    }
}
impl Eq for WindowVars {}

static_id! {
    pub(crate) static ref WINDOW_VARS_ID: StateId<WindowVars>;
}

/// Identifies a variable update set from the view-process.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct SetFromViewTag;