//! Generates a renderer-agnostic display list from a laid-out tree.

//!

//! This module is the bridge between the layout solver and the compositor/renderer.

//! Key types:

//! - [`DisplayList`] — flat, paint-order-sorted list of drawing commands

//! - [`DisplayListItem`] — a single drawing primitive or state-management command

//! - [`DisplayListBuilder`] — internal builder that accumulates items during generation

//!

//! Entry points:

//! - [`generate_display_list`] — converts a laid-out [`LayoutTree`] into a [`DisplayList`]

//! - [`paginate_display_list_with_slicer_and_breaks`] — slices a display list into pages

//!

//! Coordinates are in **absolute window-logical pixels** ([`WindowLogicalRect`]).

//! HiDPI scaling and scroll-offset conversion happen in the compositor.

use std::{collections::{BTreeMap, HashMap}, sync::Arc};

use azul_core::{

    dom::{DomId, FormattingContext, NodeId, NodeType, ScrollbarOrientation},

    geom::{LogicalPosition, LogicalRect, LogicalSize},

    gpu::GpuValueCache,

    hit_test::ScrollPosition,

    hit_test_tag::{CursorType, TAG_TYPE_CURSOR, TAG_TYPE_DOM_NODE},

    resources::{

        IdNamespace, ImageRef, OpacityKey, RendererResources, TransformKey,

    },

    transform::ComputedTransform3D,

    selection::{Selection, SelectionRange, TextSelection},

    styled_dom::StyledDom,

    ui_solver::GlyphInstance,

};

use azul_css::{

    css::CssPropertyValue,

    format_rust_code::GetHash,

    props::{

        basic::{ColorU, FontRef, PixelValue},

        layout::{LayoutDisplay, LayoutOverflow, LayoutPosition},

        property::{CssProperty, CssPropertyType},

        style::{

            background::{ConicGradient, ExtendMode, LinearGradient, RadialGradient},

            border_radius::StyleBorderRadius,

            box_shadow::{BoxShadowClipMode, StyleBoxShadow},

            filter::{StyleFilter, StyleFilterVec},

            BorderStyle, LayoutBorderBottomWidth, LayoutBorderLeftWidth, LayoutBorderRightWidth,

            LayoutBorderTopWidth, StyleBorderBottomColor, StyleBorderBottomStyle,

            StyleBorderLeftColor, StyleBorderLeftStyle, StyleBorderRightColor,

            StyleBorderRightStyle, StyleBorderTopColor, StyleBorderTopStyle,

        },

    },

    LayoutDebugMessage,

};

#[cfg(feature = "text_layout")]

use crate::text3;

#[cfg(feature = "text_layout")]

use crate::text3::cache::{InlineShape, PositionedItem};

use crate::{

    debug_info,

    font_traits::{

        FontHash, FontLoaderTrait, ImageSource, InlineContent, ParsedFontTrait, ShapedItem,

        UnifiedLayout,

    },

    solver3::{

        getters::{

            get_background_color, get_background_contents, get_border_info, get_border_radius,

            get_break_after, get_break_before, get_caret_style,

            get_overflow_clip_margin_property, get_overflow_x, get_overflow_y,

            get_scrollbar_gutter_property, get_scrollbar_info_from_layout, get_scrollbar_style, get_selection_style,

            get_style_border_radius, get_visibility, get_z_index, is_forced_page_break, BorderInfo, CaretStyle,

            ComputedScrollbarStyle, SelectionStyle,

        },

        layout_tree::{LayoutNode, LayoutNodeHot, LayoutNodeWarm, LayoutTree},

        positioning::get_position_type,

        scrollbar::{ScrollbarRequirements, compute_scrollbar_geometry_with_button_size},

        LayoutContext, LayoutError, Result,

    },

};

/// Border widths for all four sides.

///

/// Each field is optional to allow partial border specifications.

/// Used in [`DisplayListItem::Border`] to specify per-side border widths.

#[derive(Debug, Clone, Copy)]

pub struct StyleBorderWidths {

    /// Top border width (CSS `border-top-width`)

    pub top: Option<CssPropertyValue<LayoutBorderTopWidth>>,

    /// Right border width (CSS `border-right-width`)

    pub right: Option<CssPropertyValue<LayoutBorderRightWidth>>,

    /// Bottom border width (CSS `border-bottom-width`)

    pub bottom: Option<CssPropertyValue<LayoutBorderBottomWidth>>,

    /// Left border width (CSS `border-left-width`)

    pub left: Option<CssPropertyValue<LayoutBorderLeftWidth>>,

}

/// Border colors for all four sides.

///

/// Each field is optional to allow partial border specifications.

/// Used in [`DisplayListItem::Border`] to specify per-side border colors.

#[derive(Debug, Clone, Copy)]

pub struct StyleBorderColors {

    /// Top border color (CSS `border-top-color`)

    pub top: Option<CssPropertyValue<StyleBorderTopColor>>,

    /// Right border color (CSS `border-right-color`)

    pub right: Option<CssPropertyValue<StyleBorderRightColor>>,

    /// Bottom border color (CSS `border-bottom-color`)

    pub bottom: Option<CssPropertyValue<StyleBorderBottomColor>>,

    /// Left border color (CSS `border-left-color`)

    pub left: Option<CssPropertyValue<StyleBorderLeftColor>>,

}

/// Border styles for all four sides.

///

/// Each field is optional to allow partial border specifications.

/// Used in [`DisplayListItem::Border`] to specify per-side border styles

/// (solid, dashed, dotted, none, etc.).

#[derive(Debug, Clone, Copy)]

pub struct StyleBorderStyles {

    /// Top border style (CSS `border-top-style`)

    pub top: Option<CssPropertyValue<StyleBorderTopStyle>>,

    /// Right border style (CSS `border-right-style`)

    pub right: Option<CssPropertyValue<StyleBorderRightStyle>>,

    /// Bottom border style (CSS `border-bottom-style`)

    pub bottom: Option<CssPropertyValue<StyleBorderBottomStyle>>,

    /// Left border style (CSS `border-left-style`)

    pub left: Option<CssPropertyValue<StyleBorderLeftStyle>>,

}

/// A rectangle in border-box coordinates (includes padding and border).

/// This is what layout calculates and stores in `used_size` and absolute positions.

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

pub struct BorderBoxRect(pub LogicalRect);

/// A `LogicalRect` known to be in **absolute window coordinates** (as output

/// by the layout engine).  All spatial bounds stored in [`DisplayListItem`] use

/// this type so that the compositor is *forced* to convert them to

/// frame-relative coordinates before passing them to WebRender.

///

/// ## Coordinate-space contract

///

/// * **Layout engine** produces `WindowLogicalRect` values.

/// * **Compositor** converts via `resolve_rect()` → WebRender `LayoutRect`.

/// * Passing a `WindowLogicalRect` directly to a WebRender push function is a

///   **type error** (it wraps `LogicalRect`, not `LayoutRect`).

///

/// See `doc/SCROLL_COORDINATE_ARCHITECTURE.md` for background.

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

pub struct WindowLogicalRect(pub LogicalRect);

impl WindowLogicalRect {

    #[inline]

    #[inline]

    /// Access the inner `LogicalRect` (still in window space – the caller is

    /// responsible for applying any offset conversion).

    #[inline]

    #[inline]

    // Convenience accessors

}

impl From<LogicalRect> for WindowLogicalRect {

    #[inline]

}

impl From<WindowLogicalRect> for LogicalRect {

    #[inline]

}

/// Simple struct for passing element dimensions to border-radius calculation

#[derive(Debug, Clone, Copy)]

pub struct PhysicalSizeImport {

    pub width: f32,

    pub height: f32,

}

/// Complete drawing information for a scrollbar with all visual components.

///

/// This contains the resolved geometry and colors for all scrollbar parts:

/// - Track: The background area where the thumb slides

/// - Thumb: The draggable indicator showing current scroll position

/// - Buttons: Optional up/down or left/right arrow buttons

/// - Corner: The area where horizontal and vertical scrollbars meet

#[derive(Debug, Clone)]

pub struct ScrollbarDrawInfo {

    /// Overall bounds of the entire scrollbar (including track and buttons)

    pub bounds: WindowLogicalRect,

    /// Scrollbar orientation (horizontal or vertical)

    pub orientation: ScrollbarOrientation,

    // Track area (the background rail)

    /// Bounds of the track area

    pub track_bounds: WindowLogicalRect,

    /// Color of the track background

    pub track_color: ColorU,

    // Thumb (the draggable part)

    /// Bounds of the thumb

    pub thumb_bounds: WindowLogicalRect,

    /// Color of the thumb

    pub thumb_color: ColorU,

    /// Border radius for rounded thumb corners

    pub thumb_border_radius: BorderRadius,

    // Optional buttons (arrows at ends)

    /// Optional decrement button bounds (up/left arrow)

    pub button_decrement_bounds: Option<WindowLogicalRect>,

    /// Optional increment button bounds (down/right arrow)

    pub button_increment_bounds: Option<WindowLogicalRect>,

    /// Color for buttons

    pub button_color: ColorU,

    /// Optional opacity key for GPU-side fading animation.

    pub opacity_key: Option<OpacityKey>,

    /// Optional transform key for GPU-side scrollbar thumb positioning.

    /// When present, the compositor will wrap the thumb in a PushReferenceFrame

    /// with PropertyBinding::Binding so WebRender can animate the thumb position

    /// without rebuilding the display list.

    pub thumb_transform_key: Option<TransformKey>,

    /// Initial transform for the scrollbar thumb (current scroll position).

    /// This is the transform applied when the display list is first built.

    /// During GPU-only scroll, synchronize_gpu_values updates this dynamically.

    pub thumb_initial_transform: ComputedTransform3D,

    /// Optional hit-test ID for WebRender hit-testing.

    pub hit_id: Option<azul_core::hit_test::ScrollbarHitId>,

    /// Whether to clip scrollbar to container's border-radius

    pub clip_to_container_border: bool,

    /// Container's border-radius (for clipping)

    pub container_border_radius: BorderRadius,

    /// Scrollbar visibility mode — used by back-registration to choose initial opacity.

    /// `Always` → initial opacity 1.0; `WhenScrolling` → initial opacity 0.0.

    pub visibility: azul_css::props::style::scrollbar::ScrollbarVisibilityMode,

}

impl BorderBoxRect {

    /// Convert border-box to content-box by subtracting padding and border.

    /// Content-box is where inline layout and text actually render.

    /// Get the inner LogicalRect

}

/// A rectangle in content-box coordinates (excludes padding and border).

/// This is where text and inline content is positioned by the inline formatter.

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

pub struct ContentBoxRect(pub LogicalRect);

impl ContentBoxRect {

    /// Get the inner LogicalRect

}

/// The final, renderer-agnostic output of the layout engine.

///

/// This is a flat list of drawing and state-management commands, already sorted

/// according to the CSS paint order. A renderer can consume this list directly.

#[derive(Debug, Default, Clone)]

pub struct DisplayList {

    pub items: Vec<DisplayListItem>,

    /// Optional mapping from item index to the DOM NodeId that generated it.

    /// Used for pagination to look up CSS break properties.

    /// Not all items have a source node (e.g., synthesized decorations).

    pub node_mapping: Vec<Option<NodeId>>,

    /// Y-positions where forced page breaks should occur (from break-before/break-after: always).

    /// These are absolute Y coordinates in the infinite canvas coordinate system.

    /// The slicer will ensure page boundaries align with these positions.

    pub forced_page_breaks: Vec<f32>,

    /// Index ranges (start, end) of display list items that belong to fixed-position elements.

    /// In paged media, these items are replicated on every page (CSS Positioned Layout §2.1).

    pub fixed_position_item_ranges: Vec<(usize, usize)>,

}

impl DisplayList {

    /// Patch text glyph data for a specific layout node without rebuilding

    /// the entire display list. Returns the damage rect covering all

    /// affected text items, or None if no matching items found.

    ///

    /// Used for GlyphSwap incremental relayout: glyphs changed but

    /// positions are identical, so only the glyph IDs need updating.

            if let DisplayListItem::Text {

                ..

                                // rect union (was crate::cpurender::union_rect, which

                                // is gated behind the `cpurender` feature; inlined here

                                // so display-list damage tracking works without it / on WASM)

                            }

                        });

        }

    /// Compute a damage rect from the difference between old and new text

    /// layout results, starting from a given line index.

            }

    /// Generates a JSON representation of the display list for debugging.

    /// This includes clip chain analysis showing how clips are stacked.

        use std::fmt::Write;

                DisplayListItem::PushClip {

                DisplayListItem::PushScrollFrame {

                DisplayListItem::Rect {

            }

        }

        )

}

/// A command in the display list. Can be either a drawing primitive or a

/// state-management instruction for the renderer's graphics context.

#[derive(Debug, Clone)]

pub enum DisplayListItem {

    // Drawing Primitives

    /// A filled rectangle with optional rounded corners.

    /// Used for backgrounds, colored boxes, and other solid fills.

    Rect {

        /// The rectangle bounds in absolute window coordinates

        bounds: WindowLogicalRect,

        /// The fill color (RGBA)

        color: ColorU,

        /// Corner radii for rounded rectangles

        border_radius: BorderRadius,

    },

    /// A selection highlight rectangle (e.g., for text selection).

    /// Rendered behind text to show selected regions.

    SelectionRect {

        /// The rectangle bounds in absolute window coordinates

        bounds: WindowLogicalRect,

        /// Corner radii for rounded selection

        border_radius: BorderRadius,

        /// The selection highlight color (typically semi-transparent)

        color: ColorU,

    },

    /// A text cursor (caret) rectangle.

    /// Typically a thin vertical line indicating text insertion point.

    CursorRect {

        /// The cursor bounds (usually narrow width)

        bounds: WindowLogicalRect,

        /// The cursor color

        color: ColorU,

    },

    /// A CSS border with per-side widths, colors, and styles.

    /// Supports different styles per side (solid, dashed, dotted, etc.).

    Border {

        /// The border-box bounds

        bounds: WindowLogicalRect,

        /// Border widths for each side

        widths: StyleBorderWidths,

        /// Border colors for each side

        colors: StyleBorderColors,

        /// Border styles for each side (solid, dashed, etc.)

        styles: StyleBorderStyles,

        /// Corner radii for rounded borders

        border_radius: StyleBorderRadius,

    },

    /// Text layout with full metadata (for PDF, accessibility, etc.)

    /// This is pushed BEFORE the individual Text items and contains

    /// the original text, glyph-to-unicode mapping, and positioning info

    TextLayout {

        layout: Arc<dyn std::any::Any + Send + Sync>, // Type-erased UnifiedLayout

        bounds: WindowLogicalRect,

        font_hash: FontHash,

        font_size_px: f32,

        color: ColorU,

    },

    /// Text rendered with individual glyph positioning (for simple renderers)

    Text {

        glyphs: Vec<GlyphInstance>,

        font_hash: FontHash,

        font_size_px: f32,

        color: ColorU,

        clip_rect: WindowLogicalRect,

        /// Layout node index that produced this text run.

        /// Enables patching glyphs without full display list regeneration.

        source_node_index: Option<usize>,

    },

    /// Underline decoration for text (CSS text-decoration: underline)

    Underline {

        bounds: WindowLogicalRect,

        color: ColorU,

        thickness: f32,

    },

    /// Strikethrough decoration for text (CSS text-decoration: line-through)

    Strikethrough {

        bounds: WindowLogicalRect,

        color: ColorU,

        thickness: f32,

    },

    /// Overline decoration for text (CSS text-decoration: overline)

    Overline {

        bounds: WindowLogicalRect,

        color: ColorU,

        thickness: f32,

    },

    Image {

        bounds: WindowLogicalRect,

        image: ImageRef,

        border_radius: BorderRadius,

    },

    /// A dedicated primitive for a scrollbar with optional GPU-animated opacity.

    /// This is a simple single-color scrollbar used for basic rendering.

    ScrollBar {

        bounds: WindowLogicalRect,

        color: ColorU,

        orientation: ScrollbarOrientation,

        /// Optional opacity key for GPU-side fading animation.

        /// If present, the renderer will use this key to look up dynamic opacity.

        /// If None, the alpha channel of `color` is used directly.

        opacity_key: Option<OpacityKey>,

        /// Optional hit-test ID for WebRender hit-testing.

        /// If present, allows event handlers to identify which scrollbar component was clicked.

        hit_id: Option<azul_core::hit_test::ScrollbarHitId>,

    },

    /// A fully styled scrollbar with separate track, thumb, and optional buttons.

    /// Used when CSS scrollbar properties are specified.

    ScrollBarStyled {

        /// Complete drawing information for all scrollbar components

        info: Box<ScrollbarDrawInfo>,

    },

    /// An embedded VirtualView that references a child DOM with its own display list.

    /// The renderer will look up the child display list by child_dom_id and

    /// render it within the bounds. The VirtualView viewport is rendered in parent

    /// coordinate space (NOT inside a scroll frame) so it stays stationary.

    /// Scroll offset is communicated to the VirtualView callback, not via WebRender.

    VirtualView {

        /// The DomId of the child DOM (similar to webrender's pipeline_id)

        child_dom_id: DomId,

        /// The bounds where the VirtualView should be rendered

        bounds: WindowLogicalRect,

        /// The clip rect for the VirtualView content

        clip_rect: WindowLogicalRect,

    },

    /// Placeholder emitted during display list generation for VirtualView nodes.

    /// `window.rs` replaces this with a real `VirtualView` item after invoking

    /// the VirtualView callback. This avoids the need for post-hoc scroll frame

    /// scanning — `window.rs` simply finds the placeholder by `node_id`.

    ///

    /// Unlike regular scrollable nodes, VirtualView nodes do NOT get a

    /// PushScrollFrame/PopScrollFrame pair. Scroll state is managed by

    /// `ScrollManager` and passed to the VirtualView callback as `scroll_offset`.

    VirtualViewPlaceholder {

        /// The DOM NodeId of the VirtualView element in the parent DOM

        node_id: NodeId,

        /// The layout bounds of the VirtualView container

        bounds: WindowLogicalRect,

        /// The clip rect (same as bounds initially, may be adjusted)

        clip_rect: WindowLogicalRect,

    },

    // --- State-Management Commands ---

    /// Pushes a new clipping rectangle onto the renderer's clip stack.

    /// All subsequent primitives will be clipped by this rect until a PopClip.

    PushClip {

        bounds: WindowLogicalRect,

        border_radius: BorderRadius,

    },

    /// Pops the current clip from the renderer's clip stack.

    PopClip,

    /// Pushes an image-based clip mask onto the renderer's clip stack.

    /// The mask image should be R8 format: white (255) = visible, black (0) = clipped.

    /// All subsequent primitives will be masked until PopImageMaskClip.

    PushImageMaskClip {

        /// The bounds of the element being clipped

        bounds: WindowLogicalRect,

        /// The mask image (R8 format)

        mask_image: ImageRef,

        /// The rect within which the mask is applied

        mask_rect: WindowLogicalRect,

    },

    /// Pops the current image mask clip from the renderer's clip stack.

    PopImageMaskClip,

    /// Defines a scrollable area. This is a specialized clip that also

    /// establishes a new coordinate system for its children, which can be offset.

    PushScrollFrame {

        /// The clip rect in the parent's coordinate space.

        clip_bounds: WindowLogicalRect,

        /// The total size of the scrollable content.

        content_size: LogicalSize,

        /// An ID for the renderer to track this scrollable area between frames.

        scroll_id: LocalScrollId,

    },

    /// Pops the current scroll frame.

    PopScrollFrame,

    /// Pushes a new stacking context for proper z-index layering.

    /// All subsequent primitives until PopStackingContext will be in this stacking context.

    PushStackingContext {

        /// The z-index for this stacking context (for debugging/validation)

        z_index: i32,

        /// The bounds of the stacking context root element

        bounds: WindowLogicalRect,

    },

    /// Pops the current stacking context.

    PopStackingContext,

    /// Pushes a reference frame with a GPU-accelerated transform.

    /// Used for CSS transforms and drag visual offsets.

    /// Creates a new spatial coordinate system for all children.

    PushReferenceFrame {

        /// The transform key for GPU-animated property binding

        transform_key: TransformKey,

        /// The initial transform value (identity for drag, computed for CSS transform)

        initial_transform: ComputedTransform3D,

        /// The bounds of the reference frame (origin = transform origin)

        bounds: WindowLogicalRect,

    },

    /// Pops the current reference frame.

    PopReferenceFrame,

    /// Defines a region for hit-testing.

    HitTestArea {

        bounds: WindowLogicalRect,

        tag: DisplayListTagId, // This would be a renderer-agnostic ID type

    },

    // --- Gradient Primitives ---

    /// A linear gradient fill.

    LinearGradient {

        bounds: WindowLogicalRect,

        gradient: LinearGradient,

        border_radius: BorderRadius,

    },

    /// A radial gradient fill.

    RadialGradient {

        bounds: WindowLogicalRect,

        gradient: RadialGradient,

        border_radius: BorderRadius,

    },

    /// A conic (angular) gradient fill.

    ConicGradient {

        bounds: WindowLogicalRect,

        gradient: ConicGradient,

        border_radius: BorderRadius,

    },

    // --- Shadow Effects ---

    /// A box shadow (either outset or inset).

    BoxShadow {

        bounds: WindowLogicalRect,

        shadow: StyleBoxShadow,

        border_radius: BorderRadius,

    },

    // --- Filter Effects ---

    /// Push a filter effect that applies to subsequent content.

    PushFilter {

        bounds: WindowLogicalRect,

        filters: Vec<StyleFilter>,

    },

    /// Pop a previously pushed filter.

    PopFilter,

    /// Push a backdrop filter (applies to content behind the element).

    PushBackdropFilter {

        bounds: WindowLogicalRect,

        filters: Vec<StyleFilter>,

    },

    /// Pop a previously pushed backdrop filter.

    PopBackdropFilter,

    /// Push an opacity layer.

    PushOpacity {

        bounds: WindowLogicalRect,

        opacity: f32,

    },

    /// Pop an opacity layer.

    PopOpacity,

    /// Push a text shadow that applies to subsequent text content.

    PushTextShadow {

        shadow: azul_css::props::style::box_shadow::StyleBoxShadow,

    },

    /// Pop all text shadows.

    PopTextShadow,

}

impl DisplayListItem {

    /// Compare two display list items for visual equality (same appearance when rendered).

    /// Used by damage computation to detect content changes within the same bounds.

    /// Conservative: returns `false` (assumes different) for complex types like Arc<dyn Any>.

            }

            }

            }

            }

            }

            }

            }

            }

            }

            // Pop items with no fields are always equal (discriminant already matched)

            (Self::PopClip, Self::PopClip)

            | (Self::PopImageMaskClip, Self::PopImageMaskClip)

            | (Self::PopScrollFrame, Self::PopScrollFrame)

            | (Self::PopStackingContext, Self::PopStackingContext)

            | (Self::PopReferenceFrame, Self::PopReferenceFrame)

            | (Self::PopFilter, Self::PopFilter)

            | (Self::PopBackdropFilter, Self::PopBackdropFilter)

            | (Self::PopOpacity, Self::PopOpacity)

            // For complex types (TextLayout with Arc, Image, gradients, etc.),

            // conservatively assume different

        }

    /// Returns true if this item is a state-management command (Push/Pop)

    /// that must always be processed to maintain correct stacks.

            Self::PushClip { .. }

            | Self::PopClip

            | Self::PushImageMaskClip { .. }

            | Self::PopImageMaskClip

            | Self::PushScrollFrame { .. }

            | Self::PopScrollFrame

            | Self::PushStackingContext { .. }

            | Self::PopStackingContext

            | Self::PushReferenceFrame { .. }

            | Self::PopReferenceFrame

            | Self::PushFilter { .. }

            | Self::PopFilter

            | Self::PushBackdropFilter { .. }

            | Self::PopBackdropFilter

            | Self::PushOpacity { .. }

            | Self::PopOpacity

            | Self::PushTextShadow { .. }

            | Self::PopTextShadow

        )

    /// Return the visual bounding rect including effects that extend beyond

    /// content bounds (e.g. box-shadow spread/blur/offset). Used for damage

    /// rect computation where we need the full repaint area.

                // Shadow can extend beyond element bounds by offset + spread + blur

            }

        }

    /// Return the bounding rect of this item, or None for push/pop commands

    /// that don't have their own visual bounds.

            Self::PopClip

            | Self::PopImageMaskClip

            | Self::PopScrollFrame

            | Self::PopStackingContext

            | Self::PopReferenceFrame

            | Self::PopFilter

            | Self::PopBackdropFilter

            | Self::PopOpacity

        }

}

// Helper structs for the DisplayList

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

pub struct BorderRadius {

    pub top_left: f32,

    pub top_right: f32,

    pub bottom_left: f32,

    pub bottom_right: f32,

}

impl BorderRadius {

}

// Dummy types for compilation

pub type LocalScrollId = u64;

/// Display list tag ID as (payload, type_marker) tuple.

/// The u16 field is used as a namespace marker:

/// - 0x0100 = DOM Node (regular interactive elements)

/// - 0x0200 = Scrollbar component

pub type DisplayListTagId = (u64, u16);

/// Internal builder to accumulate display list items during generation.

#[derive(Debug, Default)]

struct DisplayListBuilder {

    items: Vec<DisplayListItem>,

    node_mapping: Vec<Option<NodeId>>,

    /// Current node being processed (set by generator)

    current_node: Option<NodeId>,

    /// Collected debug messages (transferred to ctx on finalize)

    debug_messages: Vec<LayoutDebugMessage>,

    /// Whether debug logging is enabled

    debug_enabled: bool,

    /// Y-positions where forced page breaks should occur

    forced_page_breaks: Vec<f32>,

    /// Index ranges of items from fixed-position elements (for paged media replication)

    fixed_position_item_ranges: Vec<(usize, usize)>,

    /// Start index of the current fixed-position element being built, if any

    fixed_position_start: Option<usize>,

}

impl DisplayListBuilder {

    /// Log a debug message if debug is enabled

    /// Build the display list and transfer debug messages to the provided option

        // Transfer collected debug messages to the context

    /// Set the current node context for subsequent push operations

    /// Mark the start of a fixed-position element's display items.

    /// Mark the end of a fixed-position element's display items.

    /// Records the (start, end) index range for paged media replication.

    /// Register a forced page break at the given Y position.

    /// This is used for CSS break-before: always and break-after: always.

        // Avoid duplicates and keep sorted

    /// Push an item and record its node mapping

    /// Push a simple single-color scrollbar (legacy method).

    /// Push a fully styled scrollbar with track, thumb, and optional buttons.

        // Only push if at least the thumb or track is visible

    /// Unified method to paint all background layers and border for an element.

    ///

    /// This consolidates the background/border painting logic that was previously

    /// duplicated across:

    /// - paint_node_background_and_border() for block elements

    /// - paint_inline_shape() for inline-block elements

    ///

    /// The backgrounds are painted in order (back to front per CSS spec), followed

    /// by the border.

        use azul_css::props::style::StyleBackgroundContent;

        // Paint all background layers in order (CSS paints backgrounds back to front)

                }

            }

        }

        // Paint border

        );

    /// Paint backgrounds and border for inline text elements.

    ///

    /// Similar to push_backgrounds_and_border but uses InlineBorderInfo which stores

    /// pre-resolved pixel values instead of CSS property values. This is used for

    /// inline (display: inline) elements where the border info is computed during

    /// text layout and stored in the glyph runs.

        use azul_css::props::style::StyleBackgroundContent;

        // Paint solid background color if present

        // Paint all background layers in order (CSS paints backgrounds back to front)