//! Resource management types for the application.

//!

//! This module contains the core types for managing application resources:

//! - `AppConfig`: application-level configuration (logging, fonts, routes, components)

//! - `ImageRef` / `ImageRefHash`: reference-counted decoded image handles

//! - `FontKey` / `FontInstanceKey` / `ImageKey`: renderer-scoped resource keys

//! - `RendererResources`: per-window font/image registry with frame-based GC

//! - `RawImage`: CPU-side pixel data with format conversion to BGRA8

//! - `build_add_font_resource_updates` / `build_add_image_resource_updates`:

//!   diff current frame against registered resources and produce WebRender updates

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

use alloc::string::ToString;

use alloc::{boxed::Box, collections::btree_map::BTreeMap, string::String, vec::Vec};

use core::{

    fmt,

    hash::{Hash, Hasher},

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

};

use azul_css::{

    format_rust_code::GetHash,

    props::basic::{

        pixel::DEFAULT_FONT_SIZE, ColorU, FloatValue, FontRef, LayoutRect, LayoutSize,

        StyleFontFamily, StyleFontFamilyVec, StyleFontSize,

    },

    system::SystemStyle,

    AzString, F32Vec, LayoutDebugMessage, OptionI32, StringVec, U16Vec, U32Vec, U8Vec,

};

use rust_fontconfig::FcFontCache;

// Re-export Core* callback types for public use

pub use crate::callbacks::{

    CoreImageCallback, CoreRenderImageCallback, CoreRenderImageCallbackType,

};

use crate::{

    callbacks::{LayoutCallback, VirtualViewCallback},

    dom::{DomId, NodeData, NodeType},

    geom::{LogicalPosition, LogicalRect, LogicalSize},

    gl::{OptionGlContextPtr, Texture},

    hit_test::DocumentId,

    id::NodeId,

    prop_cache::CssPropertyCache,

    refany::RefAny,

    styled_dom::{

        NodeHierarchyItemId, StyleFontFamiliesHash, StyleFontFamilyHash, StyledDom, StyledNodeState,

    },

    ui_solver::GlyphInstance,

    window::{AzStringPair, OptionChar, StringPairVec},

    xml::{

        ComponentDef, ComponentDefVec, ComponentId, ComponentLibrary, ComponentLibraryVec,

        ComponentSource, RegisterComponentFn, RegisterComponentLibraryFn,

    },

    FastBTreeSet, OrderedMap,

};

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

#[repr(C)]

pub struct DpiScaleFactor {

    pub inner: FloatValue,

}

impl DpiScaleFactor {

}

/// Determines what happens when all application windows are closed

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

#[repr(C)]

pub enum AppTerminationBehavior {

    /// Return control to main() when all windows are closed (if platform supports it).

    /// On macOS, this exits the NSApplication run loop and returns to main().

    /// This is useful if you want to clean up resources or restart the event loop.

    ReturnToMain,

    /// Keep the application running even when all windows are closed.

    /// This is the standard macOS behavior (app stays in dock until explicitly quit).

    RunForever,

    /// Immediately terminate the process when all windows are closed.

    /// Calls std::process::exit(0).

    EndProcess,

}

impl Default for AppTerminationBehavior {

        // Default: End the process when all windows close (cross-platform behavior)

}

/// A named font bundled with the application (name + raw bytes).

/// The name is used to reference the font in CSS (e.g. `font-family: "MyFont"`).

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

#[repr(C)]

pub struct NamedFont {

    /// The font family name to use in CSS (e.g. "Roboto", "MyCustomFont")

    pub name: AzString,

    /// Raw font file bytes (TTF, OTF, etc.)

    pub bytes: U8Vec,

}

impl_option!(

    NamedFont,

    OptionNamedFont,

    copy = false,

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

);

impl NamedFont {

}

impl_vec!(NamedFont, NamedFontVec, NamedFontVecDestructor, NamedFontVecDestructorType, NamedFontVecSlice, OptionNamedFont);

impl_vec_mut!(NamedFont, NamedFontVec);

impl_vec_debug!(NamedFont, NamedFontVec);

impl_vec_partialeq!(NamedFont, NamedFontVec);

impl_vec_eq!(NamedFont, NamedFontVec);

impl_vec_partialord!(NamedFont, NamedFontVec);

impl_vec_ord!(NamedFont, NamedFontVec);

impl_vec_hash!(NamedFont, NamedFontVec);

impl_vec_clone!(NamedFont, NamedFontVec, NamedFontVecDestructor);

/// Descriptor for a font that the layout engine currently has loaded in its

/// font cache.

///

/// Returned by `CallbackInfo::get_loaded_fonts()`. The `font_hash` field is

/// the same `u64` carried by `DisplayListItem::Text` glyph runs, so a callback

/// can correlate a loaded font with the text runs that use it and then fetch

/// the raw bytes via `CallbackInfo::get_loaded_font_bytes(font_hash)` (e.g. to

/// embed every font the layout actually used into a generated PDF).

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

#[repr(C)]

pub struct LoadedFont {

    /// Stable hash of the parsed font, identical to the `font_hash` stored on

    /// `DisplayListItem::Text` glyph runs. Use this to look up the bytes with

    /// `CallbackInfo::get_loaded_font_bytes`.

    pub font_hash: u64,

    /// PostScript / family name from the font's `name` table, or an empty

    /// string if the font did not provide one.

    pub family_name: AzString,

    /// Total number of glyphs in the font (from the `maxp` table).

    pub num_glyphs: u32,

    /// `true` if the source font bytes are retained and can be retrieved with

    /// `CallbackInfo::get_loaded_font_bytes(font_hash)`. Fonts loaded on the

    /// production (lazy mmap) path retain their bytes; some test-only fonts do

    /// not.

    pub has_bytes: bool,

}

impl_option!(

    LoadedFont,

    OptionLoadedFont,

    copy = false,

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

);

impl LoadedFont {

}

impl_vec!(LoadedFont, LoadedFontVec, LoadedFontVecDestructor, LoadedFontVecDestructorType, LoadedFontVecSlice, OptionLoadedFont);

impl_vec_mut!(LoadedFont, LoadedFontVec);

impl_vec_debug!(LoadedFont, LoadedFontVec);

impl_vec_partialeq!(LoadedFont, LoadedFontVec);

impl_vec_eq!(LoadedFont, LoadedFontVec);

impl_vec_partialord!(LoadedFont, LoadedFontVec);

impl_vec_ord!(LoadedFont, LoadedFontVec);

impl_vec_hash!(LoadedFont, LoadedFontVec);

impl_vec_clone!(LoadedFont, LoadedFontVec, LoadedFontVecDestructor);

/// Configuration for how fonts should be loaded at app startup.

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

#[repr(C, u8)]

pub enum FontLoadingConfig {

    /// Load all system fonts (default behavior, can be slow on systems with many fonts)

    LoadAllSystemFonts,

    /// Only load fonts for specific families (faster startup).

    /// Generic families like "sans-serif" are automatically expanded to OS-specific fonts.

    LoadOnlyFamilies(StringVec),

    /// Don't load any system fonts, only use bundled fonts

    BundledFontsOnly,

}

impl Default for FontLoadingConfig {

}

/// Mock environment for CSS evaluation.

/// 

/// Allows overriding auto-detected system properties for testing and development.

/// Any field set to `None` will use the auto-detected value.

/// Any field set to `Some(...)` will override the auto-detected value.

/// 

/// # Example

/// ```rust

/// # use azul_core::resources::CssMockEnvironment;

/// use azul_css::dynamic_selector::{

///     OsCondition, ThemeCondition, OsVersion,

///     OptionOsCondition, OptionThemeCondition, OptionOsVersion,

/// };

/// 

/// // Mock a Linux dark theme environment on any platform

/// let mock = CssMockEnvironment {

///     os: OptionOsCondition::Some(OsCondition::Linux),

///     theme: OptionThemeCondition::Some(ThemeCondition::Dark),

///     ..Default::default()

/// };

/// 

/// // Mock Windows XP for retro testing

/// let mock = CssMockEnvironment {

///     os: OptionOsCondition::Some(OsCondition::Windows),

///     os_version: OptionOsVersion::Some(OsVersion::WIN_XP),

///     ..Default::default()

/// };

/// ```

#[derive(Debug, Clone, Default)]

#[repr(C)]

pub struct CssMockEnvironment {

    /// Override the current theme (light/dark)

    pub theme: azul_css::dynamic_selector::OptionThemeCondition,

    /// Override the current language (BCP 47 tag, e.g., "de-DE", "en-US")

    pub language: azul_css::OptionString,

    /// Override the detected OS version

    pub os_version: azul_css::dynamic_selector::OptionOsVersion,

    /// Override the detected operating system

    pub os: azul_css::dynamic_selector::OptionOsCondition,

    /// Override the Linux desktop environment (only applies when os = Linux)

    pub desktop_env: azul_css::dynamic_selector::OptionLinuxDesktopEnv,

    /// Override viewport dimensions (for @media queries)

    /// Only use for testing - normally set by window size

    pub viewport_width: azul_css::OptionF32,

    pub viewport_height: azul_css::OptionF32,

    /// Override the reduced motion preference

    pub prefers_reduced_motion: azul_css::OptionBool,

    /// Override the high contrast preference

    pub prefers_high_contrast: azul_css::OptionBool,

}

impl CssMockEnvironment {

    /// Create a mock for Linux environment

    /// Create a mock for Windows environment

    /// Create a mock for macOS environment

    /// Create a mock for dark theme

    /// Create a mock for light theme

    /// Apply this mock to a DynamicSelectorContext

            } else {

            };

            } else {

            };

}

impl_option!(

    CssMockEnvironment,

    OptionCssMockEnvironment,

    copy = false,

    [Debug, Clone]

);

/// A route mapping a URL pattern to a layout callback.

///

/// Routes are cross-platform: on desktop, switching routes swaps the

/// active layout callback and triggers `RefreshDom`. On web, it also

/// calls `history.pushState()` for browser navigation.

///

/// # Pattern syntax

///

/// - `"/"` — exact root

/// - `"/about"` — exact path

/// - `"/user/:id"` — parameterized segment, `/user/42` yields `id = "42"`

///

/// # C API

/// ```c

/// AzAppConfig_addRoute(&config, AzString_fromConstStr("/user/:id"), layout_user);

/// ```

#[repr(C)]

pub struct Route {

    /// URL pattern (e.g. `"/"`, `"/about"`, `"/user/:id"`)

    pub pattern: AzString,

    /// Layout callback invoked when this route is active

    pub layout_callback: LayoutCallback,

}

impl Clone for Route {

}

impl fmt::Debug for Route {

}

impl Eq for Route {}

impl_option!(Route, OptionRoute, copy = false, [Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash]);

impl_vec!(Route, RouteVec, RouteVecDestructor, RouteVecDestructorType, RouteVecSlice, OptionRoute);

impl_vec_mut!(Route, RouteVec);

impl_vec_debug!(Route, RouteVec);

impl_vec_clone!(Route, RouteVec, RouteVecDestructor);

impl_vec_partialeq!(Route, RouteVec);

impl_vec_eq!(Route, RouteVec);

impl_vec_partialord!(Route, RouteVec);

impl_vec_ord!(Route, RouteVec);

impl_vec_hash!(Route, RouteVec);

/// Result of matching a URL against a route pattern.

///

/// Stores the matched pattern and any extracted parameters.

/// Available to layout callbacks via `LayoutCallbackInfo::get_route_param()`.

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

#[repr(C)]

pub struct RouteMatch {

    /// The matched route pattern (e.g. `"/user/:id"`)

    pub pattern: AzString,

    /// Extracted parameters (e.g. `[("id", "42")]`)

    pub params: StringPairVec,

}

impl RouteMatch {

    /// Get a route parameter by key.

}

impl_option!(RouteMatch, OptionRouteMatch, copy = false, [Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash]);

/// Match a URL path against a route pattern, extracting parameters.

///

/// Returns `Some(RouteMatch)` with extracted params on match, `None` otherwise.

///

/// # Examples

/// - pattern `"/user/:id"`, path `"/user/42"` → `Some(RouteMatch { params: [("id","42")] })`

/// - pattern `"/"`, path `"/"` → `Some(RouteMatch { params: [] })`

/// - pattern `"/about"`, path `"/settings"` → `None`

    }

/// Configuration for optional features, such as whether to enable logging or panic hooks

#[derive(Debug, Clone)]

#[repr(C)]

pub struct AppConfig {

    /// If enabled, logs error and info messages.

    ///

    /// Default is `LevelFilter::Error` to log all errors by default

    pub log_level: AppLogLevel,

    /// If the app crashes / panics, a window with a message box pops up.

    /// Setting this to `false` disables the popup box.

    pub enable_visual_panic_hook: bool,

    /// If this is set to `true` (the default), a backtrace + error information

    /// gets logged to stdout and the logging file (only if logging is enabled).

    pub enable_logging_on_panic: bool,

    /// (STUB) Whether keyboard navigation should be enabled (default: true).

    /// Currently not implemented.

    pub enable_tab_navigation: bool,

    /// Determines what happens when all windows are closed.

    /// Default: EndProcess (terminate when last window closes).

    pub termination_behavior: AppTerminationBehavior,

    /// Icon provider for the application.

    /// Register icons here before calling App::run().

    /// Each window will clone this provider (cheap, Arc-based).

    pub icon_provider: crate::icon::IconProviderHandle,

    /// Fonts bundled with the application.

    /// These fonts are loaded into memory and take priority over system fonts.

    pub bundled_fonts: NamedFontVec,

    /// Configuration for how system fonts should be loaded.

    /// Default: LoadAllSystemFonts (scan all system fonts at startup)

    pub font_loading: FontLoadingConfig,

    /// Optional mock environment for CSS evaluation.

    /// 

    /// When set, this overrides the auto-detected system properties (OS, theme, etc.)

    /// for CSS @-rules and dynamic selectors. This is useful for:

    /// - Testing OS-specific styles on a different platform

    /// - Screenshot testing with consistent environment

    /// - Previewing how the app looks on different systems

    /// 

    /// Default: None (use auto-detected system properties)

    pub mock_css_environment: OptionCssMockEnvironment,

    /// System style detected at startup (theme, colors, fonts, etc.)

    /// 

    /// This is detected once at `AppConfig::create()` and passed to all windows.

    /// You can override this after creation to use a custom system style,

    /// for example to test how your app looks on a different platform.

    pub system_style: SystemStyle,

    /// Component libraries registered at startup.

    ///

    /// Use `add_component()` to register individual components, or

    /// `add_component_library()` to register entire libraries.

    /// User-registered (and built-in) component libraries.

    ///

    /// The 52 built-in HTML elements are automatically registered by

    /// `AppConfig::create()` via `register_builtin_components`.

    /// Additional libraries can be added with `add_component_library`.

    pub component_libraries: ComponentLibraryVec,

    /// Registered routes mapping URL patterns to layout callbacks.

    ///

    /// Cross-platform: on desktop, the active route determines which layout

    /// callback runs. On web, routes map to HTTP endpoints and browser URLs.

    ///

    /// The first route (or `"/"`) is the default. Use `add_route()` to register.

    pub routes: RouteVec,

}

impl AppConfig {

        // Dogfood: register the 52 built-in HTML elements via the

        // same `add_component_library` API that users call.

        );

    /// Create config with a mock CSS environment for testing

    /// 

    /// This allows you to simulate how your app would look on a different OS,

    /// with a different theme, language, or accessibility settings.

    /// 

    /// # Example

    /// ```rust

    /// # use azul_core::resources::{AppConfig, CssMockEnvironment};

    /// # use azul_css::dynamic_selector::{OsCondition, OptionOsCondition, ThemeCondition, OptionThemeCondition};

    /// let config = AppConfig::create()

    ///     .with_mock_environment(CssMockEnvironment {

    ///         os: OptionOsCondition::Some(OsCondition::Linux),

    ///         theme: OptionThemeCondition::Some(ThemeCondition::Dark),

    ///         ..Default::default()

    ///     });

    /// ```

    /// Register a single component into a named library.

    ///

    /// Calls `register_fn` immediately and adds the returned `ComponentDef`

    /// to the library named `library`. If no library with that name exists,

    /// a new one is created. If a component with the same `id.name` already

    /// exists in the library, it is replaced.

    ///

    /// # C API

    /// ```c

    /// AzAppConfig_addComponent(&config, AzString_fromConstStr("mylib"), my_register_fn);

    /// ```

    /// Register an entire component library.

    ///

    /// Calls `register_fn` immediately and adds the returned

    /// `ComponentLibrary` to the config. Uses `name` as the library name

    /// (overriding whatever the function sets). If a library with the same

    /// name already exists, it is replaced wholesale.

    ///

    /// # C API

    /// ```c

    /// AzAppConfig_addComponentLibrary(&config, AzString_fromConstStr("vendor"), my_lib_fn);

    /// ```

    /// Register a route mapping a URL pattern to a layout callback.

    ///

    /// On web: each route becomes an HTTP endpoint. On desktop: the first

    /// route (or `"/"`) is the initial layout, and `CallbackInfo::switch_route()`

    /// swaps the active callback.

    ///

    /// # C API

    /// ```c

    /// AzAppConfig_addRoute(&config, AzString_fromConstStr("/user/:id"), layout_user);

    /// ```

        // Replace existing route with the same pattern

    /// Find the route matching a given URL path.

    ///

    /// Returns the matched `Route` and a `RouteMatch` with extracted parameters.

        }

}

impl Default for AppConfig {

}

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

#[repr(C)]

pub enum AppLogLevel {

    Off,

    Error,

    Warn,

    Info,

    Debug,

    Trace,

}

/// Metadata (but not storage) describing an image In WebRender.

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

#[repr(C)]

pub struct ImageDescriptor {

    /// Format of the image data.

    pub format: RawImageFormat,

    /// Width and height of the image data, in pixels.

    pub width: usize,

    pub height: usize,

    /// The number of bytes from the start of one row to the next. If non-None,

    /// `compute_stride` will return this value, otherwise it returns

    /// `width * bpp`. Different source of images have different alignment

    /// constraints for rows, so the stride isn't always equal to width * bpp.

    pub stride: OptionI32,

    /// Offset in bytes of the first pixel of this image in its backing buffer.

    /// This is used for tiling, wherein WebRender extracts chunks of input images

    /// in order to cache, manipulate, and render them individually. This offset

    /// tells the texture upload machinery where to find the bytes to upload for

    /// this tile. Non-tiled images generally set this to zero.

    pub offset: i32,

    /// Various bool flags related to this descriptor.

    pub flags: ImageDescriptorFlags,

}

/// Various flags that are part of an image descriptor.

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

#[repr(C)]

pub struct ImageDescriptorFlags {

    /// Whether this image is opaque, or has an alpha channel. Avoiding blending

    /// for opaque surfaces is an important optimization.

    pub is_opaque: bool,

    /// Whether to allow the driver to automatically generate mipmaps. If images

    /// are already downscaled appropriately, mipmap generation can be wasted

    /// work, and cause performance problems on some cards/drivers.

    ///

    /// See https://github.com/servo/webrender/pull/2555/

    pub allow_mipmaps: bool,

}

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

pub struct IdNamespace(pub u32);

impl ::core::fmt::Display for IdNamespace {

}

impl ::core::fmt::Debug for IdNamespace {

}

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

#[repr(C)]

pub enum RawImageFormat {

    R8,

    RG8,

    RGB8,

    RGBA8,

    R16,

    RG16,

    RGB16,

    RGBA16,

    BGR8,

    BGRA8,

    RGBF32,

    RGBAF32,

}

// NOTE: starts at 1 (0 = DUMMY)

static IMAGE_KEY: AtomicU64 = AtomicU64::new(1);

static FONT_KEY: AtomicU64 = AtomicU64::new(0);

static FONT_INSTANCE_KEY: AtomicU64 = AtomicU64::new(0);

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

pub struct ImageKey {

    pub namespace: IdNamespace,

    pub key: u64,

}

impl ImageKey {

    pub const DUMMY: Self = Self {

        namespace: IdNamespace(0),

        key: 0,

    };

}

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

pub struct FontKey {

    pub namespace: IdNamespace,

    pub key: u64,

}

impl FontKey {

}

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

pub struct FontInstanceKey {

    pub namespace: IdNamespace,

    pub key: u64,

}

impl FontInstanceKey {

}

// NOTE: This type should NOT be exposed in the API!

// The only public functions are the constructors

#[derive(Debug)]

pub enum DecodedImage {

    /// Image that has a reserved key, but no data, i.e it is not yet rendered

    /// or there was an error during rendering

    NullImage {

        width: usize,

        height: usize,

        format: RawImageFormat,

        /// Sometimes images need to be tagged with extra data

        tag: Vec<u8>,

    },

    // OpenGl texture

    Gl(Texture),

    // Image backed by CPU-rendered pixels

    Raw((ImageDescriptor, ImageData)),

    // Same as `Texture`, but rendered AFTER the layout has been done

    Callback(CoreImageCallback),

    // YUVImage(...)

    // VulkanSurface(...)

    // MetalSurface(...),

    // DirectXSurface(...)

}

#[derive(Debug)]

#[repr(C)]

pub struct ImageRef {

    /// Shared pointer to an opaque implementation of the decoded image

    pub data: *const DecodedImage,

    /// How many copies does this image have (if 0, the font data will be deleted on drop)

    pub copies: *const AtomicUsize,

    pub run_destructor: bool,

}

impl ImageRef {

}

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

#[repr(C)]

pub struct ImageRefHash {

    pub inner: usize,

}

impl_option!(

    ImageRef,

    OptionImageRef,

    copy = false,

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

);

impl ImageRef {

    /// If *copies = 1, returns the internal image data

        unsafe {

            } else {

            }

        }

        }

        }

    /// In difference to the default shallow copy, creates a new image ref

            DecodedImage::NullImage {

            // NOTE: textures cannot be deep-copied yet (since the OpenGL calls for that

            // are missing from the trait), so calling clone() on a GL texture will result in an

            // empty image

            // WARNING: the data may still be a U8Vec<'static> - the data may still not be

            // actually cloned. The data only gets cloned on a write operation

            }

        };

        }

        }

        }

        }

    // OptionRawImage

                        // Clone the SharedRawImageData (increments ref count),

                        // then try to extract or convert to U8Vec

                        } else {

                            // Multiple references exist, need to copy the data

                        }

                    }

                },

                premultiplied_alpha: true,

            }),

        }

    /// Get raw bytes from the image as a slice

    /// Returns None if this is not a Raw image or if it's an External image

            },

        }

    /// Get a pointer to the raw bytes for debugging/profiling purposes

    /// Returns a unique pointer for this ImageRef's data

            },

        }

    /// NOTE: returns (0, 0) for a Callback

            }

            }

            ),

        }

    // pub fn new_vulkan(...) -> Self

}

unsafe impl Send for ImageRef {}

unsafe impl Sync for ImageRef {}

impl PartialEq for ImageRef {

}

impl PartialOrd for ImageRef {

}

impl Ord for ImageRef {

}

impl Eq for ImageRef {}

impl Hash for ImageRef {

    {

}

impl Clone for ImageRef {

        unsafe {

        }

}

impl Drop for ImageRef {

        unsafe {

        }

}

/// Convert a stable ImageRefHash directly to an ImageKey.

///

/// `ImageKey.key` is a `u64`, so the pointer-derived `ImageRefHash.inner: usize`

/// round-trips losslessly on both 32- and 64-bit platforms without any folding.

/// Stores the resources for the application, such as fonts, images and cached

/// texts, also clipboard strings

///

/// Images and fonts can be references across window contexts (not yet tested,

/// but should work).

#[derive(Debug)]

pub struct ImageCache {

    /// The AzString is the string used in the CSS, i.e. url("my_image") = "my_image" -> ImageId(4)

    ///

    /// NOTE: This is the only map that is modifiable by the user and that has to be manually

    /// managed all other maps are library-internal only and automatically delete their

    /// resources once they aren't needed anymore

    pub image_id_map: OrderedMap<AzString, ImageRef>,

}

impl Default for ImageCache {

}

impl ImageCache {

    // -- ImageId cache

}

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

pub struct ResolvedImage {

    pub key: ImageKey,

    pub descriptor: ImageDescriptor,

}

/// Trait for accessing font resources

pub trait RendererResourcesTrait: core::fmt::Debug {

    /// Get a font family hash from a font families hash

    fn get_font_family(

        &self,

        style_font_families_hash: &StyleFontFamiliesHash,

    ) -> Option<&StyleFontFamilyHash>;

    /// Get a font key from a font family hash

    fn get_font_key(&self, style_font_family_hash: &StyleFontFamilyHash) -> Option<&FontKey>;

    /// Get a registered font and its instances from a font key

    fn get_registered_font(

        &self,

        font_key: &FontKey,

    ) -> Option<&(FontRef, OrderedMap<(Au, DpiScaleFactor), FontInstanceKey>)>;

    /// Get image information from an image hash

    fn get_image(&self, hash: &ImageRefHash) -> Option<&ResolvedImage>;

    /// Update an image descriptor for an existing image hash

    fn update_image(

        &mut self,

        image_ref_hash: &ImageRefHash,

        descriptor: crate::resources::ImageDescriptor,

    );

}

// Implementation for the original RendererResources struct

impl RendererResourcesTrait for RendererResources {

}

/// Renderer resources that manage font, image and font instance keys.

/// RendererResources are local to each renderer / window, since the

/// keys are not shared across renderers

///

/// The resources are automatically managed, meaning that they each new frame

/// (signified by start_frame_gc and end_frame_gc)

pub struct RendererResources {

    /// All image keys currently active in the RenderApi

    pub currently_registered_images: OrderedMap<ImageRefHash, ResolvedImage>,

    /// Reverse lookup: ImageKey -> ImageRefHash for display list translation

    pub image_key_map: OrderedMap<ImageKey, ImageRefHash>,

    /// All font keys currently active in the RenderApi

    pub currently_registered_fonts:

        OrderedMap<FontKey, (FontRef, OrderedMap<(Au, DpiScaleFactor), FontInstanceKey>)>,

    /// Fonts registered on the last frame

    ///

    /// Fonts differ from images in that regard that we can't immediately

    /// delete them on a new frame, instead we have to delete them on "current frame + 1"

    /// This is because when the frame is being built, we do not know

    /// whether the font will actually be successfully loaded

    pub last_frame_registered_fonts:

        OrderedMap<FontKey, OrderedMap<(Au, DpiScaleFactor), FontInstanceKey>>,

    /// Map from the calculated families vec (["Arial", "Helvetica"])

    /// to the final loaded font that could be loaded

    /// (in this case "Arial" on Windows and "Helvetica" on Mac,

    /// because the fonts are loaded in fallback-order)

    pub font_families_map: OrderedMap<StyleFontFamiliesHash, StyleFontFamilyHash>,

    /// Same as AzString -> ImageId, but for fonts, i.e. "Roboto" -> FontId(9)

    pub font_id_map: OrderedMap<StyleFontFamilyHash, FontKey>,

    /// Direct mapping from font hash (from FontRef) to FontKey

    /// TODO: This should become part of SharedFontRegistry

    pub font_hash_map: OrderedMap<u64, FontKey>,

}

impl fmt::Debug for RendererResources {

        )

}

impl Default for RendererResources {