repose_ui/

windowing.rs

use std::cell::RefCell;
use std::collections::HashMap;
use std::rc::Rc;

use repose_core::{
    AlignItems, Color, CursorIcon, Dp, DpOffset, DpSize, JustifyContent, Modifier,
    MutableInteractionSource, PaddingValues, PointerButton, PointerEvent, PointerEventKind, Px,
    Rect, Size, Sp, StateColors, Vec2, View, request_frame,
};

use crate::{Box, Column, Row, Spacer, Text, TextStyle, ViewExt, ZStack};

const TITLE_BAR_HEIGHT: Dp = Dp(32.0);
const WINDOW_PADDING: Dp = Dp(8.0);
const RESIZE_HANDLE: Dp = Dp(10.0);
const WINDOW_Z_BASE: f32 = 10_000.0;
const WINDOW_Z_STEP: f32 = 10.0;
const KEEP_VISIBLE_DP: f32 = 24.0;

#[derive(Clone)]
pub struct WindowAction {
    pub label: String,
    pub on_click: Rc<dyn Fn()>,
}

#[derive(Clone)]
pub struct FloatingWindow {
    pub id: u64,
    pub title: String,
    pub content: Rc<dyn Fn() -> View>,
    pub on_close: Option<Rc<dyn Fn()>>,
    /// Position in [`Dp`] from the host's top-left corner.
    pub position: DpOffset,
    /// Size in [`Dp`].
    pub size: DpSize,
    /// Minimum size in [`Dp`].
    pub min_size: DpSize,
    /// Maximum size in [`Dp`] (optional).
    pub max_size: Option<DpSize>,
    pub resizable: bool,
    pub closable: bool,
    pub draggable: bool,
    pub actions: Vec<WindowAction>,
}

impl FloatingWindow {
    pub fn new(id: u64, title: impl Into<String>, content: Rc<dyn Fn() -> View>) -> Self {
        Self {
            id,
            title: title.into(),
            content,
            on_close: None,
            position: DpOffset::new(Dp(40.0), Dp(40.0)),
            size: DpSize::new(Dp(420.0), Dp(300.0)),
            min_size: DpSize::new(Dp(220.0), Dp(160.0)),
            max_size: None,
            resizable: true,
            closable: true,
            draggable: true,
            actions: Vec::new(),
        }
    }

    pub fn position(mut self, x: Dp, y: Dp) -> Self {
        self.position = DpOffset::new(x, y);
        self
    }

    pub fn size(mut self, width: Dp, height: Dp) -> Self {
        self.size = DpSize::new(width, height);
        self
    }

    pub fn min_size(mut self, width: Dp, height: Dp) -> Self {
        self.min_size = DpSize::new(width, height);
        self
    }

    pub fn max_size(mut self, width: Dp, height: Dp) -> Self {
        self.max_size = Some(DpSize::new(width, height));
        self
    }

    pub fn resizable(mut self, resizable: bool) -> Self {
        self.resizable = resizable;
        self
    }

    pub fn closable(mut self, closable: bool) -> Self {
        self.closable = closable;
        self
    }

    pub fn draggable(mut self, draggable: bool) -> Self {
        self.draggable = draggable;
        self
    }

    pub fn actions(mut self, actions: Vec<WindowAction>) -> Self {
        self.actions = actions;
        self
    }

    pub fn on_close(mut self, on_close: Rc<dyn Fn()>) -> Self {
        self.on_close = Some(on_close);
        self
    }
}

#[derive(Clone, Default)]
pub struct WindowManagerState {
    pub windows: Vec<FloatingWindow>,
    next_id: u64,
    pub active: Option<u64>,
    window_index: HashMap<u64, usize>,
}

impl WindowManagerState {
    pub fn new() -> Self {
        Self {
            windows: Vec::new(),
            next_id: 1,
            active: None,
            window_index: HashMap::new(),
        }
    }

    pub fn alloc_id(&mut self) -> u64 {
        let id = self.next_id;
        self.next_id += 1;
        id
    }

    fn reindex_windows(&mut self) {
        self.window_index.clear();
        self.window_index.extend(
            self.windows
                .iter()
                .enumerate()
                .map(|(index, window)| (window.id, index)),
        );
    }

    fn window_index(&mut self, id: u64) -> Option<usize> {
        if let Some(&index) = self.window_index.get(&id)
            && self
                .windows
                .get(index)
                .is_some_and(|window| window.id == id)
        {
            return Some(index);
        }
        let index = self.windows.iter().position(|window| window.id == id)?;
        self.reindex_windows();
        Some(index)
    }

    pub fn open(&mut self, window: FloatingWindow) {
        let window_id = window.id;
        if let Some(pos) = self.window_index(window_id) {
            self.windows[pos] = window;
        } else {
            self.windows.push(window);
            self.reindex_windows();
        }
        self.bring_to_front(window_id);
    }

    pub fn close(&mut self, id: u64) -> bool {
        let Some(idx) = self.window_index(id) else {
            return false;
        };
        self.windows.remove(idx);
        self.reindex_windows();
        if self.active == Some(id) {
            self.active = self.windows.last().map(|w| w.id);
        }
        true
    }

    pub fn bring_to_front(&mut self, id: u64) -> bool {
        let Some(idx) = self.window_index(id) else {
            return false;
        };
        let window = self.windows.remove(idx);
        self.windows.push(window);
        self.active = Some(id);
        self.reindex_windows();
        true
    }

    pub fn set_position(&mut self, id: u64, position: DpOffset) -> bool {
        let Some(index) = self.window_index(id) else {
            return false;
        };
        self.windows[index].position = position;
        true
    }

    pub fn set_size(&mut self, id: u64, size: DpSize) -> bool {
        let Some(index) = self.window_index(id) else {
            return false;
        };
        self.windows[index].size = size;
        true
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ResizeHandle {
    Left,
    Right,
    Top,
    Bottom,
    TopLeft,
    TopRight,
    BottomLeft,
    BottomRight,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum DragKind {
    Move,
    Resize(ResizeHandle),
}

#[derive(Clone, Copy, Debug)]
pub(crate) struct DragState {
    window_id: u64,
    kind: DragKind,
    start_pointer: Vec2,
    start_pos: Vec2,
    start_size: Size,
    min_size: Size,
    max_size: Option<Size>,
}

/// Ephemeral, reusable window behavior handle. Created inside [`WindowHost`] and
/// passed to the [`WindowModifierExt`] helpers so custom chrome can reuse the
/// exact same window behavior.
#[derive(Clone)]
pub struct WindowHostHandle {
    pub(crate) state: Rc<RefCell<WindowManagerState>>,
    pub(crate) bounds: Rc<RefCell<Rect>>,
    pub(crate) drag_state: Rc<RefCell<Option<DragState>>>,
}

fn cursor_for_resize_handle(handle: ResizeHandle) -> CursorIcon {
    use ResizeHandle::*;
    match handle {
        Top | Bottom => CursorIcon::NsResize,
        Left | Right => CursorIcon::EwResize,
        TopLeft | BottomRight => CursorIcon::NwseResize,
        TopRight | BottomLeft => CursorIcon::NeswResize,
    }
}

/// Modular window behavior modifiers. Lets custom chrome reuse window behavior:
///
/// ```ignore
/// use repose_ui::windowing::{WindowModifierExt, WindowHostHandle};
/// Row(Modifier::new().window_drag_region(&host, window_id)).child(...)
/// ```
pub trait WindowModifierExt: Sized {
    /// Bring this window to the front when the region is pressed.
    fn window_focus_region(self, host: &WindowHostHandle, window_id: u64) -> Modifier;

    /// Make this node a drag region that moves the window.
    fn window_drag_region(self, host: &WindowHostHandle, window_id: u64) -> Modifier;

    /// Make this node a resize handle for the given edge/corner.
    fn window_resize_handle(
        self,
        host: &WindowHostHandle,
        window_id: u64,
        handle: ResizeHandle,
    ) -> Modifier;

    /// Shared "while dragging" continuation: move + end. Used by both the drag
    /// region and resize handles.
    fn window_drag_continuation(self, host: &WindowHostHandle, window_id: u64) -> Modifier;
}

impl WindowModifierExt for Modifier {
    fn window_focus_region(self, host: &WindowHostHandle, window_id: u64) -> Modifier {
        let state = host.state.clone();

        self.on_pointer_down(move |pe: PointerEvent| {
            if matches!(pe.event, PointerEventKind::Down(PointerButton::Primary)) {
                state.borrow_mut().bring_to_front(window_id);
                request_frame();
            }
        })
    }

    fn window_drag_region(self, host: &WindowHostHandle, window_id: u64) -> Modifier {
        let drag_state_down = host.drag_state.clone();
        let state_down = host.state.clone();

        self.cursor(CursorIcon::Grab)
            .on_pointer_down(move |pe: PointerEvent| {
                if !matches!(pe.event, PointerEventKind::Down(PointerButton::Primary)) {
                    return;
                }

                let (pos, size, min_size, max_size) = {
                    let st = state_down.borrow();
                    let Some(w) = st.windows.iter().find(|w| w.id == window_id) else {
                        return;
                    };
                    (w.position, w.size, w.min_size, w.max_size)
                };

                if drag_state_down.borrow().is_some() {
                    return;
                }
                *drag_state_down.borrow_mut() = Some(DragState {
                    window_id,
                    kind: DragKind::Move,
                    start_pointer: px_vec_to_dp(pe.position_in_window()),
                    start_pos: Vec2 {
                        x: pos.x.0,
                        y: pos.y.0,
                    },
                    start_size: Size {
                        width: size.width.0,
                        height: size.height.0,
                    },
                    min_size: Size {
                        width: min_size.width.0,
                        height: min_size.height.0,
                    },
                    max_size: max_size.map(|s| Size {
                        width: s.width.0,
                        height: s.height.0,
                    }),
                });

                state_down.borrow_mut().bring_to_front(window_id);
                pe.consume();
                request_frame();
            })
            .window_drag_continuation(host, window_id)
    }

    fn window_resize_handle(
        self,
        host: &WindowHostHandle,
        window_id: u64,
        handle: ResizeHandle,
    ) -> Modifier {
        let drag_state_down = host.drag_state.clone();
        let state_down = host.state.clone();

        self.cursor(cursor_for_resize_handle(handle))
            .on_pointer_down(move |pe: PointerEvent| {
                if !matches!(pe.event, PointerEventKind::Down(PointerButton::Primary)) {
                    return;
                }

                let (pos, size, min_size, max_size) = {
                    let st = state_down.borrow();
                    let Some(w) = st.windows.iter().find(|w| w.id == window_id) else {
                        return;
                    };
                    (w.position, w.size, w.min_size, w.max_size)
                };

                if drag_state_down.borrow().is_some() {
                    return;
                }
                *drag_state_down.borrow_mut() = Some(DragState {
                    window_id,
                    kind: DragKind::Resize(handle),
                    start_pointer: px_vec_to_dp(pe.position_in_window()),
                    start_pos: Vec2 {
                        x: pos.x.0,
                        y: pos.y.0,
                    },
                    start_size: Size {
                        width: size.width.0,
                        height: size.height.0,
                    },
                    min_size: Size {
                        width: min_size.width.0,
                        height: min_size.height.0,
                    },
                    max_size: max_size.map(|s| Size {
                        width: s.width.0,
                        height: s.height.0,
                    }),
                });

                state_down.borrow_mut().bring_to_front(window_id);
                pe.consume();
                request_frame();
            })
            .window_drag_continuation(host, window_id)
    }

    fn window_drag_continuation(self, host: &WindowHostHandle, window_id: u64) -> Modifier {
        let drag_state_move = host.drag_state.clone();
        let state_move = host.state.clone();
        let bounds_move = host.bounds.clone();

        let drag_state_up = host.drag_state.clone();
        let drag_state_cancel = host.drag_state.clone();

        self.on_pointer_move(move |pe: PointerEvent| {
            let Some(ds) = *drag_state_move.borrow() else {
                return;
            };
            if ds.window_id != window_id {
                return;
            }

            let cur = px_vec_to_dp(pe.position_in_window());
            let delta = Vec2 {
                x: cur.x - ds.start_pointer.x,
                y: cur.y - ds.start_pointer.y,
            };

            let bounds = *bounds_move.borrow();
            let (pos, size) = apply_drag(ds, delta, bounds);

            let mut st = state_move.borrow_mut();
            st.set_position(window_id, DpOffset::new(Dp(pos.x), Dp(pos.y)));
            st.set_size(window_id, DpSize::new(Dp(size.width), Dp(size.height)));
            pe.consume();
            request_frame();
        })
        .on_pointer_up(move |pe: PointerEvent| {
            let clearing = drag_state_up
                .borrow()
                .as_ref()
                .is_some_and(|d| d.window_id == window_id);
            if clearing {
                *drag_state_up.borrow_mut() = None;
                pe.consume();
                request_frame();
            }
        })
        .on_pointer_cancel(move |_pe: PointerEvent| {
            let clearing = drag_state_cancel
                .borrow()
                .as_ref()
                .is_some_and(|d| d.window_id == window_id);
            if clearing {
                *drag_state_cancel.borrow_mut() = None;
                request_frame();
            }
        })
    }
}

pub fn WindowHost(
    key: impl Into<String>,
    modifier: Modifier,
    state: Rc<RefCell<WindowManagerState>>,
    content: View,
) -> View {
    let key = key.into();
    let bounds = repose_core::remember_with_key(format!("window:bounds:{key}"), || {
        RefCell::new(Rect::default())
    });
    let drag_state = repose_core::remember_with_key(format!("window:drag:{key}"), || {
        RefCell::new(None::<DragState>)
    });

    let host = WindowHostHandle {
        state: state.clone(),
        bounds: bounds.clone(),
        drag_state: drag_state.clone(),
    };

    let bounds_capture = bounds.clone();
    let host_mod = modifier.painter(move |_scene, rect_px, _alpha| {
        let mut bounds_dp = rect_px_to_dp(rect_px);
        bounds_dp.x = 0.0;
        bounds_dp.y = 0.0;
        *bounds_capture.borrow_mut() = bounds_dp;
    });

    let active_id = state.borrow().active;
    let windows = state.borrow().windows.clone();

    let window_views = windows
        .into_iter()
        .enumerate()
        .map(|(idx, window)| {
            let z_base = WINDOW_Z_BASE + (idx as f32 * WINDOW_Z_STEP);
            let chrome_z = 2.0;
            let content_z = 1.0;

            let window_id = window.id;
            let window_actions = window.actions.clone();
            let window_closable = window.closable;
            let window_on_close = window.on_close.clone();
            let window_content = window.content.clone();
            let window_pos = window.position;
            let window_size = window.size;
            let window_title = window.title.clone();
            let window_draggable = window.draggable;
            let window_resizable = window.resizable;

            let is_active = active_id == Some(window_id);
            let th = repose_core::locals::theme();
            let border_color = if is_active {
                th.focus
            } else {
                th.outline_variant
            };
            let title_fg = if is_active {
                th.on_surface
            } else {
                th.on_surface_variant
            };
            let title_bg = if is_active {
                th.surface_variant
            } else {
                th.surface
            };

            let bring_to_front = {
                let state = state.clone();
                move || {
                    state.borrow_mut().bring_to_front(window_id);
                    request_frame();
                }
            };

            let is_dragging = host
                .drag_state
                .borrow()
                .as_ref()
                .is_some_and(|d| d.window_id == window_id && d.kind == DragKind::Move);
            let title_cursor = if is_dragging {
                CursorIcon::Grabbing
            } else {
                CursorIcon::Grab
            };

            let title_bar = {
                let actions = window_actions.clone();
                let close_enabled = window_closable;
                let close_state = state.clone();
                let close_handler = window_on_close.clone();
                let focus_state = state.clone();
                let mut action_views = Vec::new();

                for (idx, action) in actions.into_iter().enumerate() {
                    let label = action.label.clone();
                    let on_click = action.on_click.clone();
                    let focus_state = focus_state.clone();
                    let action_id = window_id;
                    let action_src: Rc<MutableInteractionSource> = repose_core::remember_with_key(
                        format!("window:action_src:{window_id}:{idx}"),
                        MutableInteractionSource::new,
                    );
                    action_views.push(
                        Row(Modifier::new()
                            .padding_values(PaddingValues {
                                left: Dp(6.0),
                                right: Dp(6.0),
                                top: Dp::ZERO,
                                bottom: Dp::ZERO,
                            })
                            .height(Dp(20.0))
                            .clip_rounded(Dp(10.0))
                            .justify_content(JustifyContent::CENTER)
                            .align_items(AlignItems::CENTER)
                            .interaction_source(&action_src)
                            .state_colors(StateColors {
                                default: th.surface_variant,
                                hovered: th.on_surface.with_alpha(16),
                                focused: th.on_surface.with_alpha(16),
                                pressed: th.on_surface.with_alpha(24),
                                dragged: th.on_surface.with_alpha(24),
                                disabled: Color::TRANSPARENT,
                            })
                            .clickable()
                            .on_pointer_down(move |_| {
                                focus_state.borrow_mut().bring_to_front(action_id);
                                (on_click)();
                                request_frame();
                            })
                            .z_index(1.0)
                            .key(key_for(window_id, 60 + idx as u64)))
                        .child(
                            Text(label)
                                .size(th.typography.label_medium)
                                .color(th.primary)
                                .single_line(),
                        ),
                    );
                }

                if close_enabled {
                    let close_id = window_id;
                    let focus_state = focus_state.clone();
                    let close_src: Rc<MutableInteractionSource> = repose_core::remember_with_key(
                        format!("window:close_src:{window_id}"),
                        MutableInteractionSource::new,
                    );
                    action_views.push(
                        Row(Modifier::new()
                            .width(Dp(20.0))
                            .height(Dp(20.0))
                            .clip_rounded(Dp(10.0))
                            .justify_content(JustifyContent::CENTER)
                            .align_items(AlignItems::CENTER)
                            .interaction_source(&close_src)
                            .state_colors(StateColors {
                                default: th.error.with_alpha(20),
                                hovered: th.error.with_alpha(40),
                                focused: th.error.with_alpha(40),
                                pressed: th.error.with_alpha(60),
                                dragged: th.error.with_alpha(60),
                                disabled: Color::TRANSPARENT,
                            })
                            .clickable()
                            .on_pointer_down(move |_| {
                                focus_state.borrow_mut().bring_to_front(close_id);
                                if let Some(handler) = close_handler.as_ref() {
                                    (handler)();
                                } else {
                                    close_state.borrow_mut().close(close_id);
                                }
                                request_frame();
                            })
                            .z_index(1.0)
                            .key(key_for(window_id, 90)))
                        .child(
                            Text("\u{E5CD}")
                                .font_family("Material Symbols Outlined")
                                .size(Sp(14.0))
                                .color(th.error),
                        ),
                    );
                }

                let mut bar_mod = Modifier::new()
                    .fill_max_width()
                    .height(TITLE_BAR_HEIGHT)
                    .background(title_bg)
                    .padding_values(PaddingValues {
                        left: Dp(10.0),
                        right: Dp(8.0),
                        top: Dp(6.0),
                        bottom: Dp(6.0),
                    })
                    .align_items(AlignItems::CENTER)
                    .key(key_for(window_id, 10));

                if window_draggable {
                    bar_mod = bar_mod
                        .window_drag_region(&host, window_id)
                        .cursor(title_cursor);
                } else {
                    bar_mod = bar_mod.on_pointer_down(move |_| bring_to_front());
                }

                let bar = Row(bar_mod).child((
                    Text(window_title)
                        .size(th.typography.title_small)
                        .color(title_fg)
                        .single_line()
                        .overflow_ellipsize(),
                    Spacer(),
                    Row(Modifier::new().align_items(AlignItems::CENTER))
                        .with_children(action_views),
                ));

                apply_z_offset(bar, chrome_z)
            };

            let content_view = {
                let content_builder = window_content.clone();
                let focus_cb = {
                    let state = state.clone();
                    Rc::new(move || {
                        state.borrow_mut().bring_to_front(window_id);
                        request_frame();
                    })
                };
                let inner = inject_focus_handlers((content_builder)(), focus_cb);
                apply_z_offset(inner, content_z)
            };

            let content_shell =
                Box(Modifier::new().fill_max_size().padding(WINDOW_PADDING)).child(content_view);

            let resize_handles = if window_resizable {
                let handles = build_resize_handles(&host, window_id);
                apply_z_offset(handles, chrome_z + 1.0)
            } else {
                Box(Modifier::new())
            };

            let column = Column(Modifier::new().fill_max_size()).child((title_bar, content_shell));

            let mut window_view = Box(Modifier::new()
                .key(key_for(window_id, 1))
                .absolute()
                .offset(Some(window_pos.x), Some(window_pos.y), None, None)
                .size(window_size.width, window_size.height)
                .background(th.surface_container_high)
                .border(Dp(1.0), border_color, th.shapes.medium)
                .clip_rounded(th.shapes.medium)
                .z_index(-1.0)
                .window_focus_region(&host, window_id))
            .child(ZStack(Modifier::new().fill_max_size()).child((column, resize_handles)));
            window_view = apply_z_offset(window_view, z_base);
            window_view
        })
        .collect::<Vec<_>>();

    Column(host_mod).child((
        content,
        Box(Modifier::new().absolute().offset(
            Some(Dp::ZERO),
            Some(Dp::ZERO),
            Some(Dp::ZERO),
            Some(Dp::ZERO),
        ))
        .child(Column(Modifier::new().fill_max_size()).with_children(window_views)),
    ))
}

fn build_resize_handles(host: &WindowHostHandle, window_id: u64) -> View {
    let handles = [
        (ResizeHandle::Left, handle_mod_left(), 20),
        (ResizeHandle::Right, handle_mod_right(), 21),
        (ResizeHandle::Top, handle_mod_top(), 22),
        (ResizeHandle::Bottom, handle_mod_bottom(), 23),
        (ResizeHandle::TopLeft, handle_mod_corner(true, true), 24),
        (ResizeHandle::TopRight, handle_mod_corner(false, true), 25),
        (ResizeHandle::BottomLeft, handle_mod_corner(true, false), 26),
        (
            ResizeHandle::BottomRight,
            handle_mod_corner(false, false),
            27,
        ),
    ];

    Column(Modifier::new().fill_max_size()).with_children(
        handles
            .into_iter()
            .map(|(handle, modifier, key)| {
                Box(modifier
                    .window_resize_handle(host, window_id, handle)
                    .key(key_for(window_id, key)))
            })
            .collect::<Vec<_>>(),
    )
}

fn handle_mod_left() -> Modifier {
    Modifier::new()
        .absolute()
        .offset(Some(Dp::ZERO), Some(Dp::ZERO), None, Some(Dp::ZERO))
        .width(RESIZE_HANDLE)
}

fn handle_mod_right() -> Modifier {
    Modifier::new()
        .absolute()
        .offset(None, Some(Dp::ZERO), Some(Dp::ZERO), Some(Dp::ZERO))
        .width(RESIZE_HANDLE)
}

fn handle_mod_top() -> Modifier {
    Modifier::new()
        .absolute()
        .offset(Some(Dp::ZERO), Some(Dp::ZERO), Some(Dp::ZERO), None)
        .height(RESIZE_HANDLE)
}

fn handle_mod_bottom() -> Modifier {
    Modifier::new()
        .absolute()
        .offset(Some(Dp::ZERO), None, Some(Dp::ZERO), Some(Dp::ZERO))
        .height(RESIZE_HANDLE)
}

fn handle_mod_corner(left: bool, top: bool) -> Modifier {
    Modifier::new()
        .absolute()
        .offset(
            if left { Some(Dp::ZERO) } else { None },
            if top { Some(Dp::ZERO) } else { None },
            if left { None } else { Some(Dp::ZERO) },
            if top { None } else { Some(Dp::ZERO) },
        )
        .size(RESIZE_HANDLE * 1.4, RESIZE_HANDLE * 1.4)
}

fn resize_from_handle(ds: DragState, handle: ResizeHandle, delta: Vec2) -> (Vec2, Size) {
    let mut pos = ds.start_pos;
    let mut size = ds.start_size;

    match handle {
        ResizeHandle::Left => {
            pos.x += delta.x;
            size.width -= delta.x;
        }
        ResizeHandle::Right => {
            size.width += delta.x;
        }
        ResizeHandle::Top => {
            pos.y += delta.y;
            size.height -= delta.y;
        }
        ResizeHandle::Bottom => {
            size.height += delta.y;
        }
        ResizeHandle::TopLeft => {
            pos.x += delta.x;
            size.width -= delta.x;
            pos.y += delta.y;
            size.height -= delta.y;
        }
        ResizeHandle::TopRight => {
            size.width += delta.x;
            pos.y += delta.y;
            size.height -= delta.y;
        }
        ResizeHandle::BottomLeft => {
            pos.x += delta.x;
            size.width -= delta.x;
            size.height += delta.y;
        }
        ResizeHandle::BottomRight => {
            size.width += delta.x;
            size.height += delta.y;
        }
    }

    (pos, size)
}

fn apply_drag(ds: DragState, delta: Vec2, bounds: Rect) -> (Vec2, Size) {
    let (mut pos, mut size) = match ds.kind {
        DragKind::Move => (
            Vec2 {
                x: ds.start_pos.x + delta.x,
                y: ds.start_pos.y + delta.y,
            },
            ds.start_size,
        ),
        DragKind::Resize(handle) => resize_from_handle(ds, handle, delta),
    };

    let min_w = ds.min_size.width.max(120.0);
    let min_h = ds.min_size.height.max(TITLE_BAR_HEIGHT.0 + 40.0);

    let mut max_w = f32::INFINITY;
    let mut max_h = f32::INFINITY;
    if let Some(max) = ds.max_size {
        max_w = max.width.max(min_w);
        max_h = max.height.max(min_h);
    }
    if bounds.w > 1.0 && bounds.h > 1.0 {
        max_w = max_w.min(bounds.w.max(min_w));
        max_h = max_h.min(bounds.h.max(min_h));
    }

    let right = pos.x + size.width;
    let bottom = pos.y + size.height;

    size.width = size.width.clamp(min_w, max_w);
    size.height = size.height.clamp(min_h, max_h);

    if let DragKind::Resize(handle) = ds.kind {
        let affects_left = matches!(
            handle,
            ResizeHandle::Left | ResizeHandle::TopLeft | ResizeHandle::BottomLeft
        );
        let affects_top = matches!(
            handle,
            ResizeHandle::Top | ResizeHandle::TopLeft | ResizeHandle::TopRight
        );
        if affects_left {
            pos.x = right - size.width;
        }
        if affects_top {
            pos.y = bottom - size.height;
        }
    }

    if bounds.w > 1.0 && bounds.h > 1.0 {
        let min_x = bounds.x - size.width + KEEP_VISIBLE_DP;
        let max_x = bounds.x + bounds.w - KEEP_VISIBLE_DP;
        let min_y = bounds.y - size.height + KEEP_VISIBLE_DP;
        let max_y = bounds.y + bounds.h - KEEP_VISIBLE_DP;
        pos.x = clamp_f32(pos.x, min_x, max_x);
        pos.y = clamp_f32(pos.y, min_y, max_y);
    }

    (pos, size)
}

fn clamp_f32(v: f32, min: f32, max: f32) -> f32 {
    if max < min { min } else { v.clamp(min, max) }
}

fn apply_z_offset(mut view: View, z: f32) -> View {
    view.modifier.z_index += z;
    if let Some(rz) = view.modifier.render_z_index {
        view.modifier.render_z_index = Some(rz + z);
    }
    view.children = view
        .children
        .into_iter()
        .map(|child| apply_z_offset(child, z))
        .collect();
    view
}

fn inject_focus_handlers(mut view: View, focus: Rc<dyn Fn()>) -> View {
    let needs_focus = modifier_handles_hit(&view.modifier)
        || view.modifier.text_input.is_some()
        || modifier_has_hit(&view.modifier);
    if needs_focus {
        let existing = view.modifier.on_pointer_down.clone();
        let focus_cb = focus.clone();
        view.modifier.on_pointer_down = Some(Rc::new(move |pe: PointerEvent| {
            if matches!(pe.event, PointerEventKind::Down(PointerButton::Primary)) {
                focus_cb();
            }
            if let Some(cb) = existing.as_ref() {
                cb(pe);
            }
        }));
    }

    view.children = view
        .children
        .into_iter()
        .map(|child| inject_focus_handlers(child, focus.clone()))
        .collect();
    view
}

fn modifier_handles_hit(modifier: &Modifier) -> bool {
    modifier.scroll.is_some()
}

fn modifier_has_hit(modifier: &Modifier) -> bool {
    modifier.click
        || modifier.on_action.is_some()
        || modifier.on_pointer_down.is_some()
        || modifier.on_pointer_move.is_some()
        || modifier.on_pointer_up.is_some()
        || modifier.on_pointer_cancel.is_some()
        || modifier.on_pointer_enter.is_some()
        || modifier.on_pointer_leave.is_some()
        || modifier.on_drag_start.is_some()
        || modifier.on_drag_end.is_some()
        || modifier.on_drag_enter.is_some()
        || modifier.on_drag_over.is_some()
        || modifier.on_drag_leave.is_some()
        || modifier.on_drop.is_some()
}

fn key_for(window_id: u64, part: u64) -> u64 {
    window_id ^ (part.wrapping_mul(0x9E3779B97F4A7C15))
}

/// Convert a px magnitude to a dp magnitude (both as `f32`).
/// Prefer the typed [`Px`] / [`Dp`] API at public boundaries; these helpers
/// serve the drag-math internals, which work in dp magnitudes.
fn px_to_dp(px: f32) -> f32 {
    Px(px).to_dp().0
}

fn px_vec_to_dp(v: Vec2) -> Vec2 {
    Vec2 {
        x: px_to_dp(v.x),
        y: px_to_dp(v.y),
    }
}

fn rect_px_to_dp(r: Rect) -> Rect {
    Rect {
        x: px_to_dp(r.x),
        y: px_to_dp(r.y),
        w: px_to_dp(r.w),
        h: px_to_dp(r.h),
    }
}