rust_widgets 1.1.3

// SPDX-FileCopyrightText: Copyright (c) 2026 Mike Li/Mikewolfli/Wei Li(mikewolfli@163.com)
// SPDX-License-Identifier: MIT

//! Win32 event notification helpers.
//!
//! This module provides Win32 event-handling helpers for the Windows platform
//! backend. All functions are `#[cfg(target_os = "windows")]`-gated to prevent
//! unused warnings on non-Windows build targets.

use crate::compat::OnceLock;
use crate::core::ObjectId;
use crate::platform::windows::types::{WindowsHandleKind, WindowsPlatform};
use crate::platform::WidgetTriggerEvent;
use crate::platform::WidgetTriggerKind;

/// Registers the `RustWidgetsWindowClass` window class via `RegisterClassW`.
/// Safe to call multiple times — registration happens exactly once.
#[cfg(target_os = "windows")]
pub(crate) fn ensure_window_class_registered() {
    unsafe extern "system" {
        fn GetModuleHandleW(lpModuleName: *const u16) -> *mut std::ffi::c_void;
    }
    static REGISTERED: OnceLock<()> = OnceLock::new();
    REGISTERED.get_or_init(|| unsafe {
        use std::ptr::null_mut;
        use winapi::um::winuser::{
            LoadCursorW, RegisterClassW, CS_HREDRAW, CS_VREDRAW, IDC_ARROW, WNDCLASSW,
        };
        let class_name = WindowsPlatform::to_wide("RustWidgetsWindowClass");
        let hinstance = GetModuleHandleW(std::ptr::null());
        let mut wnd_class: WNDCLASSW = std::mem::zeroed();
        wnd_class.style = CS_HREDRAW | CS_VREDRAW;
        wnd_class.lpfnWndProc = Some(super::types::rw_wnd_proc);
        wnd_class.hInstance = hinstance as _;
        wnd_class.hCursor = LoadCursorW(null_mut(), IDC_ARROW);
        wnd_class.lpszClassName = class_name.as_ptr();
        // RegisterClassW returns an ATOM (nonzero on success, 0 on failure).
        // If registration fails, the OnceLock prevents retry. The subsequent
        // CreateWindowExW call in create_window will return null, which is
        // already handled by the caller.
        if RegisterClassW(&wnd_class) == 0 {
            log::error!("[windows] RegisterClassW failed — window class not registered");
        }
    });
}

/// Global pointer to the active `WindowsPlatform` instance, stored at `init()` time.
#[cfg(target_os = "windows")]
static ACTIVE_WINDOWS_PLATFORM: OnceLock<usize> = OnceLock::new();

/// Returns a reference to the active `WindowsPlatform`, or `None` if not yet initialized.
#[cfg(target_os = "windows")]
pub(crate) fn active_windows_platform() -> Option<&'static WindowsPlatform> {
    let ptr = *ACTIVE_WINDOWS_PLATFORM.get()? as *const WindowsPlatform;
    if ptr.is_null() {
        None
    } else {
        Some(unsafe { &*ptr })
    }
}

/// Register the active platform pointer so that the window procedure can find it.
/// Called once during `WindowsPlatform::init()`.
#[cfg(target_os = "windows")]
pub(crate) fn register_active_platform(platform: &'static WindowsPlatform) {
    if let Err(prev) = ACTIVE_WINDOWS_PLATFORM.set(platform as *const WindowsPlatform as usize) {
        log::error!("[windows] register_active_platform already set — ignoring duplicate");
        let _ = prev;
    }
}

/// Map a Win32 notification code to a `WidgetTriggerKind` for the given widget kind.
///
/// The mapping itself lives in [`crate::platform::windows_notify`] so that it is
/// type-checked and unit-tested on every host, not only on Windows.
#[cfg(target_os = "windows")]
pub(crate) fn control_notify_kind_for_widget(
    kind: WindowsHandleKind,
    notify_code: u32,
) -> Option<WidgetTriggerKind> {
    crate::platform::windows_notify::control_notify_kind_for_widget(kind, notify_code)
}

/// Enqueue a typed trigger event derived from a Win32 notification code.
/// Returns `true` if the event was successfully enqueued.
#[cfg(target_os = "windows")]
pub(crate) fn enqueue_control_notify_event(
    platform: &WindowsPlatform,
    widget_id: ObjectId,
    notify_code: u32,
) -> bool {
    let widget_kind = match platform.state.kind_of(widget_id) {
        Some(kind) => kind,
        None => return false,
    };
    let kind = match control_notify_kind_for_widget(widget_kind, notify_code) {
        Some(kind) => kind,
        None => return false,
    };
    if let Ok(mut events) = platform.menu_state.pending_widget_events.lock() {
        events.push_back(WidgetTriggerEvent { widget_id, kind });
        // Dual-emit: a ComboBox selection change also counts as a value change
        // for cross-platform event parity.
        if crate::platform::windows_notify::combo_selchange_is_dual_emitted(widget_kind, kind) {
            events
                .push_back(WidgetTriggerEvent { widget_id, kind: WidgetTriggerKind::ValueChanged });
        }
        return true;
    }
    false
}

/// Resolve a `WidgetTriggerKind` from a widget kind and raw notification code.
/// Used by the `WM_NOTIFY` handler in the window procedure.
///
/// Delegates to the host-compilable `windows_notify` module.
#[cfg(target_os = "windows")]
pub(crate) fn notify_kind_for_widget(
    kind: WindowsHandleKind,
    notify_code: u32,
) -> Option<WidgetTriggerKind> {
    crate::platform::windows_notify::notify_kind_for_widget(kind, notify_code)
}