//! Built-in widgets for the Azul GUI system

/// Implements `Display, Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Hash`

/// for a Callback with a `.cb` field.

///

/// This is necessary to work around for <https://github.com/rust-lang/rust/issues/54508>

///

/// # Host-invoker plumbing for managed-FFI bindings

///

/// Widget callbacks have varying shapes — some are

/// `(RefAny, CallbackInfo) -> Update` (Button), others add a state

/// struct (CheckBox/Tab/etc.), a few have two extras (`ListView`). The

/// macro therefore does **not** auto-emit an `impl_managed_callback!`

/// invocation; per-widget files apply it themselves with the right

/// extras list. The base invocation still produces the standard

/// `Display`/`Debug`/`Clone`/`From<CallbackType>`/`From<Callback>` impls

/// that all widget callbacks share.

#[macro_export]

macro_rules! impl_widget_callback {

    (

        $callback_wrapper:ident,

        $option_callback_wrapper:ident,

        $callback_value:ident,

        $callback_ty:ident

    ) => {

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

        #[repr(C)]

        pub struct $callback_wrapper {

            pub refany: RefAny,

            pub callback: $callback_value,

        }

        #[repr(C)]

        pub struct $callback_value {

            pub cb: $callback_ty,

            /// For FFI: stores the foreign callable (e.g., `PyFunction`)

            /// Native Rust code sets this to None

            pub ctx: azul_core::refany::OptionRefAny,

        }

        azul_css::impl_option!(

            $callback_wrapper,

            $option_callback_wrapper,

            copy = false,

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

        );

        impl $callback_value {

            /// Create a new callback with just a function pointer (for native Rust code)

        }

        impl ::core::fmt::Display for $callback_value {

        }

        impl ::core::fmt::Debug for $callback_value {

        }

        impl Clone for $callback_value {

        }

        impl core::hash::Hash for $callback_value {

            {

        }

        impl PartialEq for $callback_value {

        }

        impl PartialOrd for $callback_value {

        }

        impl Ord for $callback_value {

        }

        impl Eq for $callback_value {}

        /// Allow creating callback from a raw function pointer

        /// Sets callable to None (for native Rust/C usage)

        impl From<$callback_ty> for $callback_value {

        }

        /// Allow creating widget callback from a generic Callback

        /// This enables Python/FFI code to pass generic callbacks to widget methods

        impl From<$crate::callbacks::Callback> for $callback_value {

            // transmute target ($callback_value's cb fn-ptr type) varies per macro

            // instantiation, so an explicit annotation can't be written generically here.

            #[allow(clippy::missing_transmute_annotations, clippy::useless_transmute)]

        }

    };

}

/// Button widget

pub mod button;

/// Checkbox widget

pub mod check_box;

/// Box displaying a color with a callback for value changes

pub mod color_input;

/// File input widget

pub mod file_input;

/// Label widget (centered text)

pub mod label;

/// Drop-down select widget

pub mod drop_down;

/// Frame container widget

pub mod frame;

/// List view widget

pub mod list_view;

/// Shared core for the video-ish widgets (camera/screencap/video): the

/// `VideoFrame` type + the GL-texture `present_frame` writeback.

///

/// See

/// `capture_common.rs`.

pub mod capture_common;

/// Camera-preview widget (P6) — a "dumb widget" owning a background capture

/// thread + a GL-texture ImageRef; no camera logic in core.

///

/// Same RefAny-

/// dataset + merge-callback design as the map widget. See `camera.rs`.

pub mod camera;

/// Screen-capture widget (P6) — identical "dumb widget" architecture to the

/// camera widget, capturing a display/window instead.

///

/// See `screencap.rs`.

pub mod screencap;

/// Video-playback widget (P6) — same "dumb widget" architecture, decoding a

/// video source (vk-video) into a GL texture.

///

/// See `video.rs`.

pub mod video;

/// Microphone-capture widget (P7) — same "dumb widget" architecture as the

/// capture widgets, audio instead of video (no GL): a background thread feeds

/// each `AudioFrame` to the user's `on_frame` hook.

///

/// See `microphone.rs`.

pub mod microphone;

/// Map widget — MVT tile + MapCSS → SVG → DOM (AzulMaps goal app, P3).

///

/// Cache lives in a dataset RefAny owned by a merge callback so it

/// survives relayout. See `layout/src/widgets/map.rs` for the design.

pub mod map;

/// Software menu-bar widget (Linux fallback when there is no native global menu).

///

/// Renders a window's `Menu` as a horizontal bar; items open dropdowns via the

/// unified `WindowPosition::RelativeToParentWindow` popup path.

pub mod menubar;

/// Node graph widget

pub mod node_graph;

/// Same as text input, but only allows numeric input

pub mod number_input;

/// Progress bar widget

pub mod progressbar;

/// Ribbon widget

pub mod ribbon;

/// Office-style backstage view (the full-window "FILE" screen): accent nav

/// column + back ring + app-provided pane content. the Office-2013-era look look by default;

/// pairs with the ribbon's `RibbonAppButton`. See `backstage.rs`.

pub mod backstage;

/// Office-style status bar: left text segments, view switcher, zoom cluster

/// (embeds the `slider` widget). the Office-2013-era look look by default. See `statusbar.rs`.

pub mod statusbar;

/// Office-style title band with a Quick Access Toolbar (save/undo/redo),

/// centered title and window buttons, drawn as DOM. the Office-2013-era look look by

/// default; use `titlebar` instead for native-caption windows. See

/// `quick_access.rs`.

pub mod quick_access;

/// Tab container widgets

pub mod tabs;

/// Single line text input widget

pub mod text_input;

/// Titlebar widget for custom window chrome

pub mod titlebar;

/// Tree view widget

pub mod tree_view;

/// Switch / toggle widget.

///

/// Boolean on/off with a sliding knob; see `switch.rs`.

pub mod switch;

/// Divider / separator rule widget (horizontal or vertical).

///

/// See `divider.rs`.

pub mod divider;

/// Card container widget.

///

/// Elevated/bordered content box (no title); see `card.rs`.

pub mod card;

/// Badge widget.

///

/// A small rounded count/status pill (stateless); see `badge.rs`.

pub mod badge;

/// Slider / range widget.

///

/// Draggable thumb on a track → numeric value; see `slider.rs`.

pub mod slider;

/// Segmented control widget.

///

/// Joined row of mutually-exclusive buttons; see `segmented.rs`.

pub mod segmented;

/// Radio-group widget.

///

/// Vertical/horizontal group of mutually-exclusive options (exactly one selected) with a circular indicator; see `radio_group.rs`.

pub mod radio_group;

/// Tooltip widget.

///

/// Shows a small text popup near an anchor on hover; see `tooltip.rs`.

pub mod tooltip;

/// Multi-line text input (text area) widget.

///

/// See `text_area.rs`.

pub mod text_area;

/// Alert / banner widget.

///

/// A coloured inline message box with an optional dismissible close button; see `alert.rs`.

pub mod alert;

/// Accordion / expander widget.

///

/// One or more collapsible titled sections; see `accordion.rs`.

pub mod accordion;

/// Avatar widget.

///

/// A circular image/initials badge (stateless); see `avatar.rs`.

pub mod avatar;

/// Chip / tag widget.

///

/// A compact rounded pill with a label + optional removable "x" (stateful when removable, mirrors alert's dismiss); see `chip.rs`.

pub mod chip;

/// Spinner / activity widget.

///

/// A static indeterminate busy ring (stateless; no animation — see the file's PARTIAL/TODO2 note); see `spinner.rs`.

pub mod spinner;

/// Popover widget.

///

/// A click-triggered floating panel holding arbitrary content, anchored to a `Dom` (the click-toggled sibling of tooltip); see `popover.rs`.

pub mod popover;

/// Combobox widget.

///

/// An editable text field with a click-toggled drop-down list of options (drop_down's select + text_input's editable field); see `combobox.rs`.

pub mod combobox;

/// Modal / dialog widget.

///

/// An in-app overlay dialog (backdrop + centred panel + arbitrary content), shown/hidden via state toggle; see `modal.rs`.

pub mod modal;

/// Toast / snackbar widget.

///

/// A transient floating notification banner pinned to a corner, manually dismissed via "x" (auto-timeout needs a host timer — see the file's TODO2); a near-clone of `alert.rs` positioned as an overlay; see `toast.rs`.

pub mod toast;

/// Breadcrumb widget.

///

/// A horizontal trail of clickable crumb links separated by "/", ending in the current (non-clickable) page; see `breadcrumb.rs`.

pub mod breadcrumb;

/// Pagination widget.

///

/// A `Prev` / page-numbers / `Next` page navigator with an active-page restyle (segmented-style); see `pagination.rs`.

pub mod pagination;

/// Stepper / wizard widget.

///

/// A horizontal numbered-step progress indicator with connector lines and an accent/muted restyle on step change (segmented-style + progressbar-style filled connector); see `stepper.rs`.

pub mod stepper;

/// Split-pane / splitter widget.

///

/// A two-pane (horizontal/vertical) container with a draggable divider that live-resizes the panes via `set_css_property` (the frame two-box layout + the map/slider pointer-drag state machine); see `split_pane.rs`.

pub mod split_pane;

/// Time picker widget.

///

/// Two clamped numeric up/down spinners (hour + minute) side by side with an optional AM/PM toggle for 12-hour mode (the number_input clamp/retext path + segmented's clickable-cell navigation); see `time_picker.rs`.

pub mod time_picker;

/// Calendar date picker widget.

///

/// A month header (‹ / `Month YYYY` / ›) above a weekday-labelled 7-column day grid computed from real calendar math; clicking a day selects + restyles it (segmented-style), and the per-cell day number is carried drop_down-style. Month nav fires on_change but cannot rebuild the grid in-widget (prominent module TODO2); see `date_picker.rs`.

pub mod date_picker;

// /// Spreadsheet (virtualized view) widget

// pub mod spreadsheet;

/// Every shipped widget's `dom()` with reasonable defaults, for lints that

/// must hold across the whole widget set (the label-convention test below and

/// `dom_lint`'s runtime-warning twin). Test-only.

#[cfg(test)]

#[cfg(test)]

#[allow(clippy::too_many_lines)]

mod label_convention {

    //! Workspace-level enforcement of the widget label convention (USER ruling,

    //! 2026-08-12): a widget must never attach state to a raw text node.

    //!

    //! `NodeType::Text` is unconditionally inline-level

    //! (`solver3::layout_tree`): it is given no rect and no `UnifiedLayout` of

    //! its own — the wrapping block box carries those. Anything attached to a

    //! text node is therefore attached to a box-less node and is silently

    //! INERT: box-model properties never paint, callbacks and `tab_index` have

    //! no hit area, and a dataset has no node to be found on.

    //!

    //! The canonical shape is `Dom::create_p_with_text(label)` (or

    //! `create_p().with_children([create_text_do_not_use_without_block_level_wrapper(label)])`) with every property on

    //! the `<p>`, or — where a dedicated styled `<div>` already is the box — a

    //! bare `create_text` leaf with the properties on that `<div>`.

    //!

    //! This generalises `ribbon`'s per-widget invariant test to every widget in

    //! the crate. Widgets that emit no text at all are still instantiated, so

    //! the list doubles as a smoke test that every `dom()` builds.

    use azul_core::dom::{Dom, NodeType};

    use azul_css::{props::basic::color::ColorU, AzString, OptionString, StringVec};

    /// Everything a node can carry that only a real box can honour, in the

    /// order the failure message lists it.

        // A subtree stylesheet on a childless text node can only target the text

        // node itself (`with_css("width: …")` parses to `* { … }`), so it is the

        // same violation wearing the other API.

    /// A user-content placeholder for the widgets that embed an arbitrary

    /// caller-supplied `Dom`. Deliberately property-free: this test governs

    /// what *widgets* emit, not what an application passes in.

        use super::node_graph::{

            InputConnectionVec, InputOutputInfo, InputOutputTypeId, InputOutputTypeIdInfoMap,

            InputOutputTypeIdInfoMapVec, InputOutputTypeIdVec, Node, NodeGraph, NodeGraphNodeId,

            NodeGraphNodePosition, NodeIdNodeMap, NodeIdNodeMapVec, NodeTypeField,

            NodeTypeFieldValue, NodeTypeFieldVec, NodeTypeId, NodeTypeIdInfoMap,

            NodeTypeIdInfoMapVec, NodeTypeInfo, OutputConnectionVec,

        };

        const TYPE_A: NodeTypeId = NodeTypeId { inner: 1 };

        const IO_A: InputOutputTypeId = InputOutputTypeId { inner: 1 };

    /// Every widget in the crate, built with defaults that actually exercise

    /// its label paths (a widget with no labels proves nothing).

    ///

    /// NOT in this list, and why:

    /// * `camera` / `microphone` / `screencap` / `video` — each `dom()` emits a

    ///   single replaced `<img>` (or nothing) fed by a background worker and

    ///   needs a device/GL config to construct; they contain no text node at

    ///   all, so there is nothing for this convention to govern.

    /// * `menubar` — a free function over a window `Menu`, not a `dom()` widget;

    ///   its bar items are already `div > bare text`.

    /// * `map`'s tile labels — emitted from the `VirtualView` render callback,

    ///   not from `dom()`, so the walk cannot reach them; they were converted by

    ///   hand and are pinned by the map widget's own tests.

        use super::{

            accordion::{Accordion, AccordionSection, AccordionSectionVec},

            alert::Alert,

            avatar::Avatar,

            backstage::{Backstage, BackstageNavItem, BackstageNavItemVec},

            badge::Badge,

            breadcrumb::Breadcrumb,

            button::Button,

            card::Card,

            check_box::CheckBox,

            chip::Chip,

            color_input::ColorInput,

            combobox::ComboBox,

            date_picker::DatePicker,

            divider::Divider,

            drop_down::DropDown,

            file_input::FileInput,

            frame::Frame,

            label::Label,

            list_view::ListView,

            map::{MapTileLayer, MapWidget},

            menubar::build_menubar_dom,

            modal::Modal,

            number_input::NumberInput,

            pagination::Pagination,

            popover::Popover,

            progressbar::ProgressBar,

            quick_access::QuickAccessBar,

            radio_group::RadioGroup,

            ribbon::{Ribbon, RibbonAppButton, RibbonButton, RibbonGroup, RibbonItem, RibbonTab, RibbonTabVec},

            segmented::Segmented,

            slider::Slider,

            spinner::Spinner,

            split_pane::{SplitDirection, SplitPane},

            statusbar::{StatusBar, StatusBarSegment, StatusBarSegmentVec},

            stepper::Stepper,

            switch::Switch,

            tabs::{TabContent, TabHeader},

            text_area::TextArea,

            text_input::TextInput,

            time_picker::TimePicker,

            titlebar::Titlebar,

            toast::Toast,

            tooltip::Tooltip,

            tree_view::{TreeView, TreeViewNode},

        };

        ]

    /// THE convention. A widget that trips this has attached box-model CSS, a

    /// callback, a `tab_index`, a dataset or children to a node that owns no

    /// rect — all of which the layout engine silently discards.

    #[test]

        );

    /// A guard on the guard: the walk must be able to SEE a violation, or the

    /// test above would pass vacuously the day someone breaks `inert_state_on`.

    #[test]

        use azul_core::dom::TabIndex;

}