//! 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 Default for WindowId {

}

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 Default for IconKey {

}

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)]

#[derive(Default)]

pub enum MouseCursorType {

    #[default]

    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,

}

/// Hardware-dependent keyboard scan code.

pub type ScanCode = u32;

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

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

#[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 {

    /// The platform's PRIMARY shortcut modifier: Cmd (super) on macOS, Ctrl

    /// everywhere else (MWA-A2). Every standard editing shortcut

    /// (copy / cut / paste / select-all / undo / redo) keys off this —

    /// hardcoding `ctrl_down()` made Cmd+C/X/V/A/Z dead on macOS, where Cmd

    /// arrives as LWin/super.

        } else {

        }

    /// 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, Eq]

);

// 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, Eq)]

#[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::{Left, Right, Middle};

        }

}

impl_option!(

    MouseState,

    OptionMouseState,

    [Debug, Copy, Clone, PartialEq, Eq, 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)]

#[derive(Default)]

pub enum ContextMenuMouseButton {

    #[default]

    Right,

    Middle,

    Left,

}

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, Eq, 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.

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

#[repr(C, u8)]

#[derive(Default)]

pub enum CursorPosition {

    OutOfWindow(LogicalPosition),

    #[default]

    Uninitialized,

    InWindow(LogicalPosition),

}

impl CursorPosition {

        }

}

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

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

///

/// Every field here maps onto a `webrender::DebugFlags` bit except

/// `show_hit_test_areas`, which is azul's own overlay. Populate it from the

/// environment with [`DebugState::from_az_overlay_env`] — see that function for

/// the verb list and why the hit-test overlay is no longer `debug_assertions`-only.

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

#[repr(C)]

pub struct DebugState {

    /// Paint a translucent red rectangle over every hit-test area.

    ///

    /// azul's own overlay, not a webrender flag: the compositor draws it while

    /// emitting `DisplayListItem::HitTestArea`, so it shows exactly the regions

    /// the hit tester will actually consider — which is the question you have

    /// when a click does nothing, or lands on the wrong node.

    pub show_hit_test_areas: bool,

    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,

}

impl DebugState {

    /// Build a `DebugState` from the `AZ_OVERLAY` environment variable.

    ///

    /// `AZ_OVERLAY` is a comma-separated list of verbs, e.g.

    ///

    /// ```text

    /// AZ_OVERLAY=hit-test

    /// AZ_OVERLAY=hit-test,overdraw,profiler

    /// AZ_OVERLAY=list          # print the verbs and exit-code nothing

    /// ```

    ///

    /// WHY THIS EXISTS: the hit-test overlay used to be `#[cfg(debug_assertions)]`

    /// in the compositor, so a debug build painted every hit-test area red and a

    /// release build painted none, with no way to ask for either. That is a

    /// debug/release divergence in VISUAL OUTPUT — running hello-world showed a

    /// red window and the reasonable first guess was "this linked the wrong

    /// DLL". It was not. An overlay you cannot turn on when you need it, and

    /// cannot turn off when you do not, is worse than no overlay.

    ///

    /// Available in RELEASE builds too, deliberately: the moment you need to see

    /// hit-test regions or overdraw is usually on the build a user is running.

    ///

    /// Unknown verbs are reported and ignored rather than fatal — a typo in a

    /// debugging aid must not stop the app you are trying to debug.

    /// Reading the environment needs std; on `no_std` there is no environment to

    /// read, so the overlay is simply off. `from_overlay_spec` stays available

    /// everywhere, so a `no_std` embedder can still enable overlays explicitly.

    #[cfg(feature = "std")]

    #[must_use]

    /// `no_std`: there is no environment, so no overlay.

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

    #[must_use]

    pub fn from_az_overlay_env() -> Self {

        Self::default()

    }

    /// The parser behind [`DebugState::from_az_overlay_env`], separated so it is

    /// testable without touching the process environment.

    #[must_use]

                // azul's own overlay.

                // webrender flags, named for what they SHOW rather than for the

                // flag constant, because the constant names are not obvious.

                // Diagnostic switches that DISABLE a stage — for bisecting which

                // stage is responsible for a visual artefact.

            }

        }

}

#[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)]

#[derive(Default)]

pub enum WindowTheme {

    DarkMode,

    #[default]

    LightMode,

}

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: Self = Self { 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 = 0x0100_0000_01b3;

        }

        const FNV_OFFSET_BASIS: u64 = 0xcbf2_9ce4_8422_2325;

        // 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 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, Eq)]

#[repr(C, u8)]

#[derive(Default)]

pub enum WindowPosition {

    #[default]

    Uninitialized,

    /// Absolute position on the virtual screen (physical px). The default for

    /// top-level windows.

    Initialized(PhysicalPositionI32),

    /// Offset (physical px) from the PARENT window's top-left corner. Used by

    /// child windows (menus, dropdowns, popups) together with

    /// `WindowCreateOptions.parent_window_id`: the backend resolves the final

    /// screen position as `parent_top_left + offset`. This is robust where

    /// absolute screen coordinates aren't available — notably Wayland, whose

    /// `xdg_popup` / subsurface protocol positions relative to the parent. Falls

    /// back to absolute (`offset` from origin) if there is no parent.

    RelativeToParentWindow(PhysicalPositionI32),

}

#[allow(variant_size_differences)] // repr(C,u8) FFI enum: boxing the large variant would change the C ABI (api.json bindings); size disparity accepted

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

#[repr(C, u8)]

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

#[derive(Default)]

pub enum ImePosition {

    #[default]

    Uninitialized,

    Initialized(LogicalRect),

}

#[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 (X11Visual) that are

// opaque platform handles, not dereferenced across threads.

unsafe impl Sync for PlatformSpecificOptions {}

#[allow(clippy::non_send_fields_in_send_ty)] // opaque platform handles, not dereferenced across threads (see note above)

unsafe impl Send for PlatformSpecificOptions {}

#[derive(Debug, Clone, PartialEq, Eq, 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,

    // NOTE: the old Windows-specific `parent_window: OptionHwndHandle` field was

    // removed in favor of the cross-platform `WindowCreateOptions.parent_window_id`

    // (+ `WindowPosition::RelativeToParentWindow`), which every backend resolves

    // through its window registry. One parenting model for all platforms.

}

impl Default for WindowsWindowOptions {

}

/// 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)]

#[derive(Default)]

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.

    #[default]

    Normal,

}

impl_option!(

    XWindowType,

    OptionXWindowType,

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

);

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

#[repr(C)]

#[derive(Default)]

pub enum UserAttentionType {

    #[default]

    None,

    Critical,

    Informational,

}