//! Window configuration types, input state, and platform-specific options.

//!

//! This module defines the core types used by the windowing system:

//!

//! - **Window configuration**: [`WindowSize`], [`WindowFlags`], [`WindowPosition`],

//!   [`RendererOptions`], [`PlatformSpecificOptions`]

//! - **Input state**: [`KeyboardState`], [`MouseState`], [`TouchState`], [`CursorPosition`]

//! - **Monitor/display info**: [`Monitor`], [`MonitorId`], [`VideoMode`]

//! - **Virtual key codes**: [`VirtualKeyCode`], [`ScanCode`]

//! - **Window icons**: [`WindowIcon`], [`TaskBarIcon`]

//! - **Platform options**: [`WindowsWindowOptions`], [`LinuxWindowOptions`],

//!   [`MacWindowOptions`], [`WasmWindowOptions`]

//!

//! These types are consumed by the platform shell backends in

//! `dll/src/desktop/shell2/{windows,macos,linux}/` and by

//! `layout/src/window_state.rs` for state management.

#[cfg(not(feature = "std"))]

use alloc::string::{String, ToString};

use alloc::{

    boxed::Box,

    collections::{btree_map::BTreeMap, btree_set::BTreeSet},

    vec::Vec,

};

use core::{

    cmp::Ordering,

    ffi::c_void,

    hash::{Hash, Hasher},

    ops,

    sync::atomic::{AtomicI64, AtomicUsize, Ordering as AtomicOrdering},

};

use azul_css::{

    css::CssPath,

    props::{

        basic::{ColorU, FloatValue, LayoutPoint, LayoutRect, LayoutSize},

        property::CssProperty,

    },

    AzString, LayoutDebugMessage, OptionF32, OptionI32, OptionString, OptionU32, U8Vec,

};

use rust_fontconfig::FcFontCache;

use crate::{

    callbacks::{LayoutCallback, LayoutCallbackType, Update},

    dom::{DomId, DomNodeId, NodeHierarchy},

    geom::{

        LogicalPosition, LogicalRect, LogicalSize, OptionLogicalSize, PhysicalPositionI32,

        PhysicalSize,

    },

    gl::OptionGlContextPtr,

    hit_test::{ExternalScrollId, OverflowingScrollNode},

    id::{NodeDataContainer, NodeId},

    refany::OptionRefAny,

    resources::{

        DpiScaleFactor, Epoch, GlTextureCache, IdNamespace, ImageCache, ImageMask, ImageRef,

        RendererResources, ResourceUpdate,

    },

    selection::SelectionState,

    styled_dom::NodeHierarchyItemId,

    task::{Instant, ThreadId, TimerId},

    FastBTreeSet, OrderedMap,

};

pub const DEFAULT_TITLE: &str = "Azul App";

static LAST_WINDOW_ID: AtomicI64 = AtomicI64::new(0);

/// Unique identifier for a window, auto-assigned via atomic counter.

#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Ord, PartialOrd)]

#[repr(transparent)]

pub struct WindowId {

    pub id: i64,

}

impl WindowId {

}

static LAST_ICON_KEY: AtomicUsize = AtomicUsize::new(0);

/// Key that is used for checking whether a window icon has changed -

/// this way azul doesn't need to diff the actual bytes, just the icon key.

/// Use `IconKey::new()` to generate a new, unique key

#[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]

#[repr(C)]

pub struct IconKey {

    icon_id: usize,

}

impl IconKey {

}

#[repr(C)]

#[derive(PartialEq, Copy, Clone, Debug, PartialOrd, Ord, Eq, Hash)]

pub struct RendererOptions {

    pub vsync: Vsync,

    pub srgb: Srgb,

    pub hw_accel: HwAcceleration,

}

impl_option!(

    RendererOptions,

    OptionRendererOptions,

    [PartialEq, Copy, Clone, Debug, PartialOrd, Ord, Eq, Hash]

);

impl Default for RendererOptions {

}

impl RendererOptions {

}

#[repr(C)]

#[derive(PartialEq, Copy, Clone, Debug, PartialOrd, Ord, Eq, Hash)]

pub enum Vsync {

    Enabled,

    Disabled,

    DontCare,

}

impl Vsync {

}

#[repr(C)]

#[derive(PartialEq, Copy, Clone, Debug, PartialOrd, Ord, Eq, Hash)]

pub enum Srgb {

    Enabled,

    Disabled,

    DontCare,

}

impl Srgb {

}

#[repr(C)]

#[derive(PartialEq, Copy, Clone, Debug, PartialOrd, Ord, Eq, Hash)]

pub enum HwAcceleration {

    Enabled,

    Disabled,

    DontCare,

}

impl HwAcceleration {

}

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C, u8)]

pub enum RawWindowHandle {

    IOS(IOSHandle),

    MacOS(MacOSHandle),

    Xlib(XlibHandle),

    Xcb(XcbHandle),

    Wayland(WaylandHandle),

    Windows(WindowsHandle),

    Web(WebHandle),

    Android(AndroidHandle),

    Unsupported,

}

// SAFETY: RawWindowHandle contains raw pointers that are only used as opaque

// identifiers for platform window handles. The handle values are not

// dereferenced across threads; they are passed to platform APIs on the main thread.

unsafe impl Send for RawWindowHandle {}

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

pub struct IOSHandle {

    pub ui_window: *mut c_void,

    pub ui_view: *mut c_void,

    pub ui_view_controller: *mut c_void,

}

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

pub struct MacOSHandle {

    pub ns_window: *mut c_void,

    pub ns_view: *mut c_void,

}

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

pub struct XlibHandle {

    /// An Xlib Window

    pub window: u64,

    pub display: *mut c_void,

}

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

pub struct XcbHandle {

    /// An X11 xcb_window_t.

    pub window: u32,

    /// A pointer to an X server xcb_connection_t.

    pub connection: *mut c_void,

}

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

pub struct WaylandHandle {

    /// A pointer to a wl_surface

    pub surface: *mut c_void,

    /// A pointer to a wl_display.

    pub display: *mut c_void,

}

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

pub struct WindowsHandle {

    /// A Win32 HWND handle.

    pub hwnd: *mut c_void,

    /// The HINSTANCE associated with this type's HWND.

    pub hinstance: *mut c_void,

}

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

pub struct WebHandle {

    /// An ID value inserted into the data attributes of the canvas element as 'raw-handle'

    ///

    /// When accessing from JS, the attribute will automatically be called rawHandle. Each canvas

    /// created by the windowing system should be assigned their own unique ID.

    /// 0 should be reserved for invalid / null IDs.

    pub id: u32,

}

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

pub struct AndroidHandle {

    /// A pointer to an ANativeWindow.

    pub a_native_window: *mut c_void,

}

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

pub enum MouseCursorType {

    Default,

    Crosshair,

    Hand,

    Arrow,

    Move,

    Text,

    Wait,

    Help,

    Progress,

    NotAllowed,

    ContextMenu,

    Cell,

    VerticalText,

    Alias,

    Copy,

    NoDrop,

    Grab,

    Grabbing,

    AllScroll,

    ZoomIn,

    ZoomOut,

    EResize,

    NResize,

    NeResize,

    NwResize,

    SResize,

    SeResize,

    SwResize,

    WResize,

    EwResize,

    NsResize,

    NeswResize,

    NwseResize,

    ColResize,

    RowResize,

}

impl Default for MouseCursorType {

}

/// Hardware-dependent keyboard scan code.

pub type ScanCode = u32;

/// Determines which keys are pressed currently (modifiers, etc.)

#[derive(Default, Debug, Clone, PartialEq)]

#[repr(C)]

pub struct KeyboardState {

    /// Currently pressed virtual keycode - **DO NOT USE THIS FOR TEXT INPUT**.

    ///

    /// For text input, use the `text_input` parameter in callbacks.

    /// For example entering `à` will fire a `VirtualKeyCode::Grave`, then `VirtualKeyCode::A`,

    /// so to correctly combine characters, the framework handles text composition internally.

    pub current_virtual_keycode: OptionVirtualKeyCode,

    /// Currently pressed virtual keycodes (READONLY) - it can happen that more than one key is

    /// pressed

    ///

    /// This is essentially an "extension" of `current_scancodes` - `current_keys` stores the

    /// characters, but what if the pressed key is not a character (such as `ArrowRight` or

    /// `PgUp`)?

    ///

    /// Note that this can have an overlap, so pressing "a" on the keyboard will insert

    /// both a `VirtualKeyCode::A` into `current_virtual_keycodes` and text input will be handled

    /// by the framework automatically for contenteditable nodes.

    pub pressed_virtual_keycodes: VirtualKeyCodeVec,

    /// Same as `current_virtual_keycodes`, but the scancode identifies the physical key pressed,

    /// independent of the keyboard layout. The scancode does not change if the user adjusts the

    /// host's keyboard map. Use when the physical location of the key is more important than

    /// the key's host GUI semantics, such as for movement controls in a first-person game

    /// (German keyboard: Z key, UK keyboard: Y key, etc.)

    pub pressed_scancodes: ScanCodeVec,

}

impl KeyboardState {

    /// Returns `true` iff every entry of `chord` is currently active in this

    /// keyboard state. Used by accelerator/keymap registrations to evaluate

    /// shortcuts like `[Ctrl, Shift, Key(VirtualKeyCode::S)]`.

    ///

    /// An empty chord matches trivially.

}

impl_option!(

    KeyboardState,

    OptionKeyboardState,

    copy = false,

    [Debug, Clone, PartialEq]

);

// char is not ABI-stable, use u32 instead

impl_option!(

    u32,

    OptionChar,

    [Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash]

);

impl_option!(

    VirtualKeyCode,

    OptionVirtualKeyCode,

    [Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash]

);

impl_vec!(VirtualKeyCode, VirtualKeyCodeVec, VirtualKeyCodeVecDestructor, VirtualKeyCodeVecDestructorType, VirtualKeyCodeVecSlice, OptionVirtualKeyCode);

impl_vec_debug!(VirtualKeyCode, VirtualKeyCodeVec);

impl_vec_partialord!(VirtualKeyCode, VirtualKeyCodeVec);

impl_vec_ord!(VirtualKeyCode, VirtualKeyCodeVec);

impl_vec_clone!(

    VirtualKeyCode,

    VirtualKeyCodeVec,

    VirtualKeyCodeVecDestructor

);

impl_vec_partialeq!(VirtualKeyCode, VirtualKeyCodeVec);

impl_vec_eq!(VirtualKeyCode, VirtualKeyCodeVec);

impl_vec_hash!(VirtualKeyCode, VirtualKeyCodeVec);

impl_vec_mut!(VirtualKeyCode, VirtualKeyCodeVec);

impl_vec_as_hashmap!(VirtualKeyCode, VirtualKeyCodeVec);

impl_vec!(ScanCode, ScanCodeVec, ScanCodeVecDestructor, ScanCodeVecDestructorType, ScanCodeVecSlice, OptionU32);

impl_vec_debug!(ScanCode, ScanCodeVec);

impl_vec_partialord!(ScanCode, ScanCodeVec);

impl_vec_ord!(ScanCode, ScanCodeVec);

impl_vec_clone!(ScanCode, ScanCodeVec, ScanCodeVecDestructor);

impl_vec_partialeq!(ScanCode, ScanCodeVec);

impl_vec_eq!(ScanCode, ScanCodeVec);

impl_vec_hash!(ScanCode, ScanCodeVec);

impl_vec_mut!(ScanCode, ScanCodeVec);

impl_vec_as_hashmap!(ScanCode, ScanCodeVec);

/// Mouse position, cursor type, user scroll input, etc.

#[derive(Debug, Copy, Clone, PartialOrd, PartialEq)]

#[repr(C)]

pub struct MouseState {

    /// Current mouse cursor type, set to `None` if the cursor is hidden. (READWRITE)

    pub mouse_cursor_type: OptionMouseCursorType,

    /// Where is the mouse cursor currently? Set to `None` if the window is not focused.

    /// (READWRITE)

    pub cursor_position: CursorPosition,

    /// Is the mouse cursor locked to the current window (important for applications like games)?

    /// (READWRITE)

    pub is_cursor_locked: bool,

    /// Is the left mouse button down? (READONLY)

    pub left_down: bool,

    /// Is the right mouse button down? (READONLY)

    pub right_down: bool,

    /// Is the middle mouse button down? (READONLY)

    pub middle_down: bool,

}

impl MouseState {

        use self::ContextMenuMouseButton::*;

        }

}

impl_option!(

    MouseState,

    OptionMouseState,

    [Debug, Copy, Clone, PartialEq, PartialOrd]

);

impl_option!(

    MouseCursorType,

    OptionMouseCursorType,

    [Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash]

);

impl Default for MouseState {

}

#[derive(Debug, Clone, PartialEq, PartialOrd, Hash, Eq, Ord)]

#[repr(C)]

pub struct VirtualKeyCodeCombo {

    pub keys: VirtualKeyCodeVec,

}

impl_option!(

    VirtualKeyCodeCombo,

    OptionVirtualKeyCodeCombo,

    copy = false,

    [Debug, Clone, PartialEq, PartialOrd, Hash, Eq, Ord]

);

#[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Hash, Eq, Ord)]

#[repr(C)]

pub enum ContextMenuMouseButton {

    Right,

    Middle,

    Left,

}

impl Default for ContextMenuMouseButton {

}

impl MouseState {

    /// Returns whether any mouse button (left, right or center) is currently held down

    /// Snapshot the button-down flags as a `MouseButtonState` for drag tracking.

}

impl From<&MouseState> for crate::events::MouseButtonState {

}

impl crate::events::MouseButtonState {

    /// Returns true if any of the tracked buttons is held down.

}

/// Result of dispatching a scroll delta into the system scroll-handling pipeline.

///

/// Returned by [`process_system_scroll`]. Higher layers can use the

/// [`ScrollResult::remaining_delta`] to forward un-consumed scroll to a parent

/// container, and [`ScrollResult::hit_scrollbar`] to distinguish scrollbar-drag

/// scrolling from wheel-on-content scrolling for hit-testing purposes.

#[derive(Debug, Default, Copy, Clone, PartialEq, PartialOrd)]

#[repr(C)]

pub struct ScrollResult {

    /// Number of scrollable nodes whose offset was updated by this dispatch.

    pub scrolled_nodes: usize,

    /// Delta that could not be consumed (overscroll). May be forwarded to a parent.

    pub remaining_delta: LogicalPosition,

    /// `true` if the dispatch hit a native scrollbar (drag), `false` for wheel/touch.

    pub hit_scrollbar: bool,

}

/// Dispatch a system scroll event and return a [`ScrollResult`] describing what

/// happened.

///

/// This is the entry point used by headless integration tests and embedders that

/// drive scroll programmatically. The richer per-document scroll handling lives

/// in `LayoutWindow::process_scroll`; this helper packages a delta into a

/// `ScrollResult` for return to callers so the result type is observable from

/// the public API.

    ScrollResult {

    }

#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]

#[repr(C, u8)]

pub enum CursorPosition {

    OutOfWindow(LogicalPosition),

    Uninitialized,

    InWindow(LogicalPosition),

}

impl Default for CursorPosition {

}

impl CursorPosition {

        }

}

/// Toggles webrender debug flags (will make stuff appear on

/// the screen that you might not want to - used for debugging purposes)

#[derive(Default, Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]

#[repr(C)]

pub struct DebugState {

    pub profiler_dbg: bool,

    pub render_target_dbg: bool,

    pub texture_cache_dbg: bool,

    pub gpu_time_queries: bool,

    pub gpu_sample_queries: bool,

    pub disable_batching: bool,

    pub epochs: bool,

    pub echo_driver_messages: bool,

    pub show_overdraw: bool,

    pub gpu_cache_dbg: bool,

    pub texture_cache_dbg_clear_evicted: bool,

    pub picture_caching_dbg: bool,

    pub primitive_dbg: bool,

    pub zoom_dbg: bool,

    pub small_screen: bool,

    pub disable_opaque_pass: bool,

    pub disable_alpha_pass: bool,

    pub disable_clip_masks: bool,

    pub disable_text_prims: bool,

    pub disable_gradient_prims: bool,

    pub obscure_images: bool,

    pub glyph_flashing: bool,

    pub smart_profiler: bool,

    pub invalidation_dbg: bool,

    pub tile_cache_logging_dbg: bool,

    pub profiler_capture: bool,

    pub force_picture_invalidation: bool,

}

#[derive(Debug, Default, Clone, PartialEq)]

#[repr(C)]

pub struct TouchState {

    /// Number of active touch points (kept in sync with `touch_points.len()`).

    pub num_touches: usize,

    /// Currently active touch points (one entry per finger / stylus).

    /// Backends update this on touch start / move / end events.

    pub touch_points: TouchPointVec,

}

/// Single touch point (finger, stylus, etc.)

#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]

#[repr(C)]

pub struct TouchPoint {

    /// Unique identifier for this touch point (persists across move events)

    pub id: u64,

    /// Current position of the touch point in logical coordinates

    pub position: LogicalPosition,

    /// Force/pressure of the touch (0.0 = no pressure, 1.0 = maximum pressure)

    /// Set to 0.5 if pressure is not available

    pub force: f32,

}

impl_option!(

    TouchPoint,

    OptionTouchPoint,

    [Debug, Copy, Clone, PartialEq, PartialOrd]

);

impl_vec!(TouchPoint, TouchPointVec, TouchPointVecDestructor, TouchPointVecDestructorType, TouchPointVecSlice, OptionTouchPoint);

impl_vec_debug!(TouchPoint, TouchPointVec);

impl_vec_clone!(TouchPoint, TouchPointVec, TouchPointVecDestructor);

impl_vec_partialeq!(TouchPoint, TouchPointVec);

/// State, size, etc of the window, for comparing to the last frame

#[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Hash, Ord, Eq)]

#[repr(C)]

pub enum WindowTheme {

    DarkMode,

    LightMode,

}

impl Default for WindowTheme {

}

impl_option!(

    WindowTheme,

    OptionWindowTheme,

    [Debug, Copy, Clone, PartialEq, PartialOrd, Ord, Eq, Hash]

);

/// Identifies a specific monitor/display

///

/// Contains both an index (for fast current-session lookup) and a stable hash

/// (for persistence across app restarts and monitor reconfigurations).

///

/// - `index`: Runtime index (0-based), may change if monitors are added/removed

/// - `hash`: Stable identifier based on monitor properties (name, size, position)

///

/// Applications can serialize `hash` to remember which monitor a window was on,

/// then search for matching hash on next launch, falling back to index or PRIMARY.

#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Ord, PartialOrd)]

#[repr(C)]

pub struct MonitorId {

    /// Runtime index of the monitor (may change between sessions)

    pub index: usize,

    /// Stable hash of monitor properties (for persistence)

    pub hash: u64,

}

impl MonitorId {

    /// Primary/default monitor (index 0, hash 0)

    pub const PRIMARY: MonitorId = MonitorId { index: 0, hash: 0 };

    /// Create a MonitorId from index only (hash will be 0)

    /// Create a MonitorId from index and hash

    /// Create a stable monitor ID from monitor properties

    ///

    /// Uses FNV-1a hash of: name + position + size

    /// This ensures the hash is stable across app restarts as long as

    /// the monitor configuration doesn't change significantly

        use core::hash::{Hash, Hasher};

        // FNV-1a hash (simple, fast, good distribution)

        struct FnvHasher(u64);

        impl Hasher for FnvHasher {

                const FNV_PRIME: u64 = 0x100000001b3;

        }

        const FNV_OFFSET_BASIS: u64 = 0xcbf29ce484222325;

        // Hash the monitor properties

}

impl_option!(

    MonitorId,

    OptionMonitorId,

    [Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash]

);

/// Complete information about a monitor/display

#[derive(Debug, PartialEq, PartialOrd, Clone)]

#[repr(C)]

pub struct Monitor {

    /// Unique identifier for this monitor (stable across frames)

    pub monitor_id: MonitorId,

    /// Human-readable name (e.g., "\\.\DISPLAY1", "HDMI-1", "Built-in Retina Display")

    pub monitor_name: OptionString,

    /// Physical size of the monitor in logical pixels

    pub size: LayoutSize,

    /// Position of the monitor in the virtual screen coordinate system

    pub position: LayoutPoint,

    /// DPI scale factor (1.0 = 96 DPI, 2.0 = 192 DPI for Retina)

    pub scale_factor: f64,

    /// Work area (monitor bounds minus taskbars/panels) in logical pixels

    pub work_area: LayoutRect,

    /// Available video modes for this monitor

    pub video_modes: VideoModeVec,

    /// Whether this is the primary/main monitor

    pub is_primary_monitor: bool,

}

impl_option!(

    Monitor,

    OptionMonitor,

    copy = false,

    [Debug, PartialEq, PartialOrd, Clone]

);

impl_vec!(Monitor, MonitorVec, MonitorVecDestructor, MonitorVecDestructorType, MonitorVecSlice, OptionMonitor);

impl_vec_debug!(Monitor, MonitorVec);

impl_vec_clone!(Monitor, MonitorVec, MonitorVecDestructor);

impl_vec_partialeq!(Monitor, MonitorVec);

impl_vec_partialord!(Monitor, MonitorVec);

impl core::hash::Hash for Monitor {

    {

}

impl Default for Monitor {

}

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

pub struct VideoMode {

    pub size: LayoutSize,

    pub bit_depth: u16,

    pub refresh_rate: u16,

}

impl_option!(

    VideoMode,

    OptionVideoMode,

    [Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash]

);

impl_vec!(VideoMode, VideoModeVec, VideoModeVecDestructor, VideoModeVecDestructorType, VideoModeVecSlice, OptionVideoMode);

impl_vec_clone!(VideoMode, VideoModeVec, VideoModeVecDestructor);

impl_vec_debug!(VideoMode, VideoModeVec);

impl_vec_partialeq!(VideoMode, VideoModeVec);

impl_vec_partialord!(VideoMode, VideoModeVec);

/// Position of the window on screen

#[derive(Debug, Copy, Clone, PartialEq)]

#[repr(C, u8)]

pub enum WindowPosition {

    Uninitialized,

    Initialized(PhysicalPositionI32),

}

impl Default for WindowPosition {

}

#[derive(Debug, Copy, Clone, PartialEq)]

#[repr(C, u8)]

/// IME composition window rectangle (cursor position + height)

pub enum ImePosition {

    Uninitialized,

    Initialized(LogicalRect),

}

impl Default for ImePosition {

}

#[derive(Debug, Copy, Clone, PartialEq, Eq, Ord, PartialOrd, Hash)]

#[repr(C)]

pub struct WindowFlags {

    /// Is the window currently maximized, minimized or fullscreen

    pub frame: WindowFrame,

    /// Window decoration style (title bar, native controls)

    pub decorations: WindowDecorations,

    /// Compositor blur/transparency effect material

    pub background_material: WindowBackgroundMaterial,

    /// Window type classification (Normal, Menu, Tooltip, Dialog)

    pub window_type: WindowType,

    /// User clicked the close button (set by WindowDelegate, checked by event loop)

    /// The close_callback can set this to false to prevent closing

    pub close_requested: bool,

    /// Is the window currently visible?

    pub is_visible: bool,

    /// Is the window always on top?

    pub is_always_on_top: bool,

    /// Whether the window is resizable

    pub is_resizable: bool,

    /// Whether the window has focus or not (mutating this will request user attention)

    pub has_focus: bool,

    /// Is smooth scrolling enabled for this window?

    pub smooth_scroll_enabled: bool,

    /// Is automatic TAB switching supported?

    pub autotab_enabled: bool,

    /// Enable client-side decorations (custom titlebar with CSD)

    /// Only effective when decorations == WindowDecorations::None

    pub has_decorations: bool,

    /// Use native menus (Win32 HMENU, macOS NSMenu) instead of Azul window-based menus

    /// Default: true on Windows/macOS, false on Linux

    pub use_native_menus: bool,

    /// Use native context menus instead of Azul window-based context menus

    /// Default: true on Windows/macOS, false on Linux

    pub use_native_context_menus: bool,

    /// Keep window above all others (even from other applications)

    /// Platform-specific: Uses SetWindowPos(HWND_TOPMOST) on Windows, [NSWindow setLevel:] on

    /// macOS, _NET_WM_STATE_ABOVE on X11, zwlr_layer_shell on Wayland

    pub is_top_level: bool,

    /// Prevent system from sleeping while window is open

    /// Platform-specific: Uses SetThreadExecutionState on Windows, IOPMAssertionCreateWithName on

    /// macOS, org.freedesktop.ScreenSaver.Inhibit on Linux

    pub prevent_system_sleep: bool,

    /// Desired fullscreen-transition style.

    ///

    /// On macOS this controls whether entering/leaving fullscreen plays the

    /// system animation (`Slow*`) or transitions immediately (`Fast*`). On

    /// other platforms `Slow*` and `Fast*` behave identically.

    ///

    /// The actual current frame state still lives in [`WindowFlags::frame`]; this

    /// field only describes how the next transition should be performed.

    pub fullscreen_mode: FullScreenMode,

}

impl_option!(

    WindowFlags,

    OptionWindowFlags,

    copy = false,

    [Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash]

);

/// Window type classification for behavior control

#[derive(Debug, Copy, Clone, PartialEq, Eq, Ord, PartialOrd, Hash)]

#[repr(C)]

pub enum WindowType {

    /// Normal application window

    Normal,

    /// Menu popup window (always-on-top, frameless, auto-closes on focus loss)

    Menu,

    /// Tooltip window (always-on-top, no interaction)

    Tooltip,

    /// Dialog window (blocks parent window)

    Dialog,

}

impl Default for WindowType {

}

/// Window frame state (normal, minimized, maximized, fullscreen)

#[derive(Debug, Copy, Clone, PartialEq, Eq, Ord, PartialOrd, Hash)]

#[repr(C)]

pub enum WindowFrame {

    Normal,

    Minimized,

    Maximized,

    Fullscreen,

}

/// Window decoration style

#[derive(Debug, Copy, Clone, PartialEq, Eq, Ord, PartialOrd, Hash)]

#[repr(C)]

pub enum WindowDecorations {

    /// Full decorations: title bar with controls

    Normal,

    /// No title text but controls visible (extended frame).

    /// The application must draw its own title text.

    NoTitle,

    /// Like `NoTitle`, but the framework auto-injects a `Titlebar`

    /// at the top of the user's DOM after calling the layout callback.

    ///

    /// The injected titlebar reads `TitlebarMetrics` from `SystemStyle` for

    /// correct padding around the OS-drawn window control buttons, uses the

    /// system title font, and carries the `__azul-native-titlebar` class for

    /// automatic window-drag activation.

    NoTitleAutoInject,

    /// No controls visible but title bar area present

    NoControls,

    /// No decorations at all (borderless)

    None,

}

impl Default for WindowDecorations {

}

/// Compositor blur/transparency effects for window background

#[derive(Debug, Copy, Clone, PartialEq, Eq, Ord, PartialOrd, Hash)]

#[repr(C)]

pub enum WindowBackgroundMaterial {

    /// No transparency or blur

    Opaque,

    /// Transparent without blur

    Transparent,

    /// macOS: Sidebar material, Windows: Acrylic light

    Sidebar,

    /// macOS: Menu material, Windows: Acrylic

    Menu,

    /// macOS: HUD material, Windows: Acrylic dark

    HUD,

    /// macOS: Titlebar material, Windows: Mica

    Titlebar,

    /// Windows: Mica Alt material

    MicaAlt,

}

impl Default for WindowBackgroundMaterial {

}

impl Default for WindowFlags {

}

impl WindowFlags {

    /// Check if window is a menu popup

    #[inline]

    /// Check if window is a tooltip

    #[inline]

    /// Check if window is a dialog

    #[inline]

    /// Check if window currently has focus

    #[inline]

    /// Check if close was requested via callback

    #[inline]

    /// Check if window has client-side decorations enabled

    #[inline]

    /// Check if native menus should be used

    #[inline]

    /// Check if native context menus should be used

    #[inline]

}

/// Platform-specific window configuration options (Windows, Linux, macOS, WASM)

#[derive(Debug, Default, Clone, PartialEq, PartialOrd)]

#[repr(C)]

pub struct PlatformSpecificOptions {

    pub windows_options: WindowsWindowOptions,

    pub linux_options: LinuxWindowOptions,

    pub mac_options: MacWindowOptions,

    pub wasm_options: WasmWindowOptions,

}

// SAFETY: PlatformSpecificOptions contains raw pointers (HwndHandle, X11Visual)

// that are opaque platform handles, not dereferenced across threads.

unsafe impl Sync for PlatformSpecificOptions {}

unsafe impl Send for PlatformSpecificOptions {}

#[derive(Debug, Clone, PartialEq, PartialOrd)]

#[repr(C)]

pub struct WindowsWindowOptions {

    /// STARTUP ONLY: Whether the window should allow drag + drop operations (default: true)

    pub allow_drag_and_drop: bool,

    /// STARTUP ONLY: Sets `WS_EX_NOREDIRECTIONBITMAP`

    pub no_redirection_bitmap: bool,

    /// STARTUP ONLY: Window icon (decoded bytes), appears at the top right corner of the window

    pub window_icon: OptionWindowIcon,

    /// READWRITE: Taskbar icon (decoded bytes), usually 256x256x4 bytes large (`ICON_BIG`).

    ///

    /// Can be changed in callbacks / at runtime.

    pub taskbar_icon: OptionTaskBarIcon,

    /// STARTUP ONLY: Pointer (casted to void pointer) to a HWND handle

    pub parent_window: OptionHwndHandle,

}

impl Default for WindowsWindowOptions {

}

/// Note: this should be a *mut HWND

pub type HwndHandle = *mut c_void;

impl_option!(

    HwndHandle,

    OptionHwndHandle,

    copy = false,

    [Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash]

);

/// X window type. Maps directly to

/// [`_NET_WM_WINDOW_TYPE`](https://specifications.freedesktop.org/wm-spec/wm-spec-1.5.html).

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

pub enum XWindowType {

    /// A desktop feature. This can include a single window containing desktop icons with the same

    /// dimensions as the screen, allowing the desktop environment to have full control of the

    /// desktop, without the need for proxying root window clicks.

    Desktop,

    /// A dock or panel feature. Typically a Window Manager would keep such windows on top of all

    /// other windows.

    Dock,

    /// Toolbar windows. "Torn off" from the main application.

    Toolbar,

    /// Pinnable menu windows. "Torn off" from the main application.

    Menu,

    /// A small persistent utility window, such as a palette or toolbox.

    Utility,

    /// The window is a splash screen displayed as an application is starting up.

    Splash,

    /// This is a dialog window.

    Dialog,

    /// A dropdown menu that usually appears when the user clicks on an item in a menu bar.

    /// This property is typically used on override-redirect windows.

    DropdownMenu,

    /// A popup menu that usually appears when the user right clicks on an object.

    /// This property is typically used on override-redirect windows.

    PopupMenu,

    /// A tooltip window. Usually used to show additional information when hovering over an object

    /// with the cursor. This property is typically used on override-redirect windows.

    Tooltip,

    /// The window is a notification.

    /// This property is typically used on override-redirect windows.

    Notification,

    /// This should be used on the windows that are popped up by combo boxes.

    /// This property is typically used on override-redirect windows.

    Combo,

    /// This indicates the the window is being dragged.

    /// This property is typically used on override-redirect windows.

    Dnd,

    /// This is a normal, top-level window.

    Normal,

}

impl_option!(

    XWindowType,

    OptionXWindowType,

    [Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash]

);

impl Default for XWindowType {

}

#[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Ord, Eq, Hash)]

#[repr(C)]

pub enum UserAttentionType {

    None,

    Critical,

    Informational,

}

impl Default for UserAttentionType {

}

/// State for tracking hover and interaction with Linux window decoration elements (CSD).

#[derive(Debug, Default, Copy, Clone, PartialEq, PartialOrd, Ord, Eq, Hash)]

#[repr(C)]

pub struct LinuxDecorationsState {

    pub is_dragging_titlebar: bool,

    pub close_button_hover: bool,

    pub maximize_button_hover: bool,

    pub minimize_button_hover: bool,

}

impl_option!(

    LinuxDecorationsState,

    OptionLinuxDecorationsState,

    [Debug, Copy, Clone, PartialEq, PartialOrd, Ord, Eq, Hash]

);

#[derive(Debug, Default, Clone, PartialEq, PartialOrd)]

#[repr(C)]

pub struct LinuxWindowOptions {

    pub wayland_theme: OptionWaylandTheme,

    pub window_icon: OptionWindowIcon,

    /// Build window with `_GTK_THEME_VARIANT` hint set to the specified value. Currently only

    /// relevant on X11. Can only be set at window creation, can't be changed in callbacks.

    pub x11_gtk_theme_variant: OptionString,

    /// Build window with a given application ID. It should match the `.desktop` file distributed

    /// with your program. Only relevant on Wayland.

    /// Can only be set at window creation, can't be changed in callbacks.

    ///

    /// For details about application ID conventions, see the

    /// [Desktop Entry Spec](https://specifications.freedesktop.org/desktop-entry-spec/desktop-entry-spec-latest.html#desktop-file-id)

    pub wayland_app_id: OptionString,

    /// Build window with `WM_CLASS` hint; defaults to the name of the binary. Only relevant on

    /// X11. Can only be set at window creation, can't be changed in callbacks.

    pub x11_wm_classes: StringPairVec,

    /// Build window with `_NET_WM_WINDOW_TYPE` hint; defaults to `Normal`. Only relevant on X11.

    /// Can only be set at window creation, can't be changed in callbacks.

    pub x11_window_types: XWindowTypeVec,

    /// (Unimplemented) - Can only be set at window creation, can't be changed in callbacks.

    pub x11_visual: OptionX11Visual,

    /// Build window with resize increment hint. Only implemented on X11.

    /// Can only be set at window creation, can't be changed in callbacks.

    pub x11_resize_increments: OptionLogicalSize,

    /// Build window with base size hint. Only implemented on X11.

    /// Can only be set at window creation, can't be changed in callbacks.

    pub x11_base_size: OptionLogicalSize,

    /// (Unimplemented) - Can only be set at window creation, can't be changed in callbacks.

    pub x11_screen: OptionI32,

    pub request_user_attention: UserAttentionType,

    /// X11-specific: Client-side decoration state (drag position, button hover, etc.)

    pub x11_decorations_state: OptionLinuxDecorationsState,

    /// Build window with override-redirect flag; defaults to false. Only relevant on X11.

    /// Can only be set at window creation, can't be changed in callbacks.

    pub x11_override_redirect: bool,

}

pub type X11Visual = *const c_void;

impl_option!(

    X11Visual,

    OptionX11Visual,

    [Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash]

);

/// A key-value pair of strings, used for X11 WM_CLASS and other platform properties

#[derive(Debug, Default, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]

#[repr(C)]

pub struct AzStringPair {

    pub key: AzString,

    pub value: AzString,

}

impl_option!(

    AzStringPair,

    OptionStringPair,

    copy = false,

    [Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash]

);

impl_vec!(AzStringPair, StringPairVec, StringPairVecDestructor, StringPairVecDestructorType, StringPairVecSlice, OptionStringPair);

impl_vec_mut!(AzStringPair, StringPairVec);

impl_vec_debug!(AzStringPair, StringPairVec);

impl_vec_partialord!(AzStringPair, StringPairVec);

impl_vec_ord!(AzStringPair, StringPairVec);

impl_vec_clone!(AzStringPair, StringPairVec, StringPairVecDestructor);

impl_vec_partialeq!(AzStringPair, StringPairVec);

impl_vec_eq!(AzStringPair, StringPairVec);

impl_vec_hash!(AzStringPair, StringPairVec);

impl_option!(

    StringPairVec,

    OptionStringPairVec,

    copy = false,

    [Debug, Clone, PartialOrd, PartialEq, Ord, Eq, Hash]

);

impl StringPairVec {

            } else {

            }

            }

        }