Improve native panel interactions and texture history

Author: gajop

native/src/sbc/panels/controls/grid.rs

@@ -384,6 +384,39 @@ pub(crate) fn list_asset_tree(
     items
 }
 
+pub(crate) fn list_assets(
+    interface: &NativeInterfaceRef,
+    dir: &str,
+    extensions: &[&str],
+) -> Vec<GridItem> {
+    list_entries(interface, dir, extensions, false)
+}
+
+/// Like [`list_assets`], but also lists sub-directories as browsable folder
+/// cells. Only the Open/Load dialog wants that: a project is an `.sdd` folder,
+/// invisible to the engine's file-only `ListDir`. Texture pickers stay
+/// file-only, or engine dirs (`bitmaps/`) would bury the textures under dozens
+/// of unrelated sub-folders.
+pub(crate) fn list_entries_with_dirs(
+    interface: &NativeInterfaceRef,
+    dir: &str,
+    extensions: &[&str],
+) -> Vec<GridItem> {
+    list_entries(interface, dir, extensions, true)
+}
+
+/// The parent of a VFS directory, or None at the root.
+pub(crate) fn parent_dir(dir: &str) -> Option<String> {
+    let trimmed = dir.trim_end_matches('/');
+    if trimmed.is_empty() {
+        return None;
+    }
+    match trimmed.rsplit_once('/') {
+        Some((parent, _)) => Some(parent.to_string()),
+        None => Some(String::new()),
+    }
+}
+
 /// The inline brush grid follows the same location/root split as
 /// [`list_asset_tree`], but brush commands consume direct VFS paths. Directory
 /// ids stay asset-relative so navigation stays within the asset-pack tree;
@@ -426,39 +459,6 @@ fn asset_pack_directory(root_dir: &str, location: &str) -> String {
     directory
 }
 
-pub(crate) fn list_assets(
-    interface: &NativeInterfaceRef,
-    dir: &str,
-    extensions: &[&str],
-) -> Vec<GridItem> {
-    list_entries(interface, dir, extensions, false)
-}
-
-/// Like [`list_assets`], but also lists sub-directories as browsable folder
-/// cells. Only the Open/Load dialog wants that: a project is an `.sdd` folder,
-/// invisible to the engine's file-only `ListDir`. Texture pickers stay
-/// file-only, or engine dirs (`bitmaps/`) would bury the textures under dozens
-/// of unrelated sub-folders.
-pub(crate) fn list_entries_with_dirs(
-    interface: &NativeInterfaceRef,
-    dir: &str,
-    extensions: &[&str],
-) -> Vec<GridItem> {
-    list_entries(interface, dir, extensions, true)
-}
-
-/// The parent of a VFS directory, or None at the root.
-pub(crate) fn parent_dir(dir: &str) -> Option<String> {
-    let trimmed = dir.trim_end_matches('/');
-    if trimmed.is_empty() {
-        return None;
-    }
-    match trimmed.rsplit_once('/') {
-        Some((parent, _)) => Some(parent.to_string()),
-        None => Some(String::new()),
-    }
-}
-
 fn list_entries(
     interface: &NativeInterfaceRef,
     dir: &str,

native/src/sbc/panels/cursor/drag_cursor.rs

@@ -23,17 +23,8 @@ pub(crate) struct DragCursor {
 }
 
 impl DragCursor {
-    /// Where the pointer is pinned. The drag's delta is measured from here,
-    /// because the pointer is put back on it after every move.
-    pub(crate) fn anchor_x(&self) -> Option<f32> {
-        self.anchor.map(|(x, _)| x as f32)
-    }
-
-    pub(crate) fn begin(&mut self, interface: &NativeInterfaceRef) {
-        let Ok(mouse) = interface.input().get_mouse_state() else {
-            return;
-        };
-        self.anchor = Some((mouse.x as i32, mouse.y as i32));
+    pub(crate) fn begin(&mut self, interface: &NativeInterfaceRef, anchor: (i32, i32)) {
+        self.anchor = Some(anchor);
 
         let ctrl = interface.unsynced_ctrl();
         if !self.assigned {
@@ -45,18 +36,15 @@ impl DragCursor {
         let _ = ctrl.set_mouse_cursor(EMPTY_CURSOR, 1.0);
     }
 
-    /// Pin the pointer back to the anchor. Called after the value has taken the
-    /// movement, so the motion is consumed rather than lost.
-    pub(crate) fn hold(&self, interface: &NativeInterfaceRef) {
-        let Some((x, y)) = self.anchor else {
-            return;
-        };
-        let ctrl = interface.unsynced_ctrl();
-        let _ = ctrl.warp_mouse(x, y);
+    /// Re-assert the empty cursor while a drag is active. Motion itself is
+    /// pinned synchronously from RmlUi's `drag` listener.
+    pub(crate) fn reassert(&self, interface: &NativeInterfaceRef) {
         // Re-assert it every tick: the engine syncs the cursor to whatever RmlUi
         // is hovering on each update, so setting it once at dragstart is undone
         // on the very next frame.
-        let _ = ctrl.set_mouse_cursor(EMPTY_CURSOR, 1.0);
+        let _ = interface
+            .unsynced_ctrl()
+            .set_mouse_cursor(EMPTY_CURSOR, 1.0);
     }
 
     pub(crate) fn end(&mut self, interface: &NativeInterfaceRef) {
@@ -68,4 +56,13 @@ impl DragCursor {
         // `SB.SetMouseCursor()` does.
         let _ = ctrl.set_mouse_cursor("", 1.0);
     }
+
+    /// End an interrupted drag without moving the cursor back into the panel.
+    /// A new press is an explicit user decision about where the pointer is, so
+    /// preserving that location avoids turning a right-click on the map into a
+    /// surprise cursor teleport.
+    pub(crate) fn cancel(&mut self, interface: &NativeInterfaceRef) {
+        self.anchor = None;
+        let _ = interface.unsynced_ctrl().set_mouse_cursor("", 1.0);
+    }
 }

native/src/sbc/panels/field.rs

@@ -34,6 +34,9 @@ pub(crate) fn new_interaction_queue() -> InteractionQueue {
 pub enum InteractionEvent {
     PointerDown {
         field: String,
+        /// Engine mouse coordinates, when the RmlUi event provided them.
+        /// Generic pointer users do not need an anchor; numeric drags do.
+        anchor: Option<(i32, i32)>,
     },
     PointerUp {
         field: String,
@@ -46,6 +49,26 @@ pub enum InteractionEvent {
     DragEnd {
         field: String,
     },
+    /// Exact horizontal movement from one RmlUi drag event. RmlUi emits this
+    /// before the pointer is put back at its drag anchor.
+    DragMove {
+        field: String,
+        dx: f32,
+    },
+    /// A numeric field asks the panel-owned presentation surface to follow its
+    /// drag. The field describes values; the surface owns all RmlUi geometry.
+    NumericDragPresentation(NumericDragPresentation),
+}
+
+#[derive(Debug, Clone)]
+pub struct NumericDragPresentation {
+    pub element: u64,
+    pub title: String,
+    pub value: String,
+    pub min: Option<String>,
+    pub max: Option<String>,
+    /// A bounded range normalised to 0..1. `None` means no fill.
+    pub progress: Option<f32>,
 }
 
 /// One field as the control channel sees it: what it is called, what it holds,
@@ -183,7 +206,10 @@ pub(crate) fn on_pointer(
     for (event, make) in [
         (
             "mousedown",
-            (|field| InteractionEvent::PointerDown { field }) as fn(String) -> InteractionEvent,
+            (|field| InteractionEvent::PointerDown {
+                field,
+                anchor: None,
+            }) as fn(String) -> InteractionEvent,
         ),
         ("mouseup", |field| InteractionEvent::PointerUp { field }),
         ("dragstart", |field| InteractionEvent::DragStart { field }),
@@ -200,6 +226,127 @@ pub(crate) fn on_pointer(
     Ok(())
 }
 
+/// Register numeric drag events with RmlUi's per-motion coordinates.
+///
+/// RmlUi captures a numeric field's drag before SBC receives normal mouse
+/// callbacks. Polling the engine cursor later made a small physical move look
+/// large when the original click landed away from the field's logical value.
+/// Instead, this mirrors Chili: consume the current RmlUi `drag` movement and
+/// immediately put the pointer back where the press began.
+pub(crate) fn on_numeric_pointer(
+    interface: &NativeInterfaceRef,
+    context: u64,
+    element: u64,
+    name: String,
+    interactions: &InteractionQueue,
+) -> Result<(), Error> {
+    let anchor = Rc::new(RefCell::new(None::<(i32, i32)>));
+
+    {
+        let queue = interactions.clone();
+        let field = name.clone();
+        let anchor = anchor.clone();
+        let iface = *interface;
+        interface
+            .rml_ui()
+            .element_add_event_listener(element, "mousedown", false, move || {
+                if current_rml_mouse_button(&iface) != Some(0) {
+                    return;
+                }
+                let Some((x, y)) = current_rml_mouse_position(&iface) else {
+                    return;
+                };
+                let Some(anchor_position) = engine_mouse_position(&iface, x, y) else {
+                    return;
+                };
+                *anchor.borrow_mut() = Some(anchor_position);
+                let _ = iface
+                    .rml_ui()
+                    .context_set_pointer_capture(context, x, y, true);
+                queue.borrow_mut().push(InteractionEvent::PointerDown {
+                    field: field.clone(),
+                    anchor: Some(anchor_position),
+                });
+            })?;
+    }
+    {
+        let queue = interactions.clone();
+        let field = name.clone();
+        let iface = *interface;
+        interface
+            .rml_ui()
+            .element_add_event_listener(element, "mouseup", false, move || {
+                if current_rml_mouse_button(&iface) != Some(0) {
+                    return;
+                }
+                let _ = iface
+                    .rml_ui()
+                    .context_set_pointer_capture(context, 0, 0, false);
+                queue.borrow_mut().push(InteractionEvent::PointerUp {
+                    field: field.clone(),
+                });
+            })?;
+    }
+    {
+        let queue = interactions.clone();
+        let field = name.clone();
+        interface
+            .rml_ui()
+            .element_add_event_listener(element, "dragstart", false, move || {
+                // RmlUi dispatches `dragstart` immediately before the first
+                // `drag`. Do not warp here: it changes the context position
+                // before that first `drag` can read its movement. The next
+                // listener consumes and pins this same physical motion.
+                queue.borrow_mut().push(InteractionEvent::DragStart {
+                    field: field.clone(),
+                });
+            })?;
+    }
+    {
+        let queue = interactions.clone();
+        let field = name.clone();
+        let anchor = anchor.clone();
+        let iface = *interface;
+        interface
+            .rml_ui()
+            .element_add_event_listener(element, "drag", false, move || {
+                let Some((mouse_x, _)) = current_rml_mouse_position(&iface) else {
+                    return;
+                };
+                let Some((anchor_x, anchor_y)) = *anchor.borrow() else {
+                    return;
+                };
+                let dx = (mouse_x - anchor_x) as f32;
+                if dx != 0.0 {
+                    queue.borrow_mut().push(InteractionEvent::DragMove {
+                        field: field.clone(),
+                        dx,
+                    });
+                    // The backend's synthetic anchor move fires `drag` once
+                    // more with zero movement. It has already restored both
+                    // pointer positions, so avoid a redundant OS cursor warp.
+                    let _ = iface.unsynced_ctrl().warp_mouse(anchor_x, anchor_y);
+                }
+            })?;
+    }
+    {
+        let queue = interactions.clone();
+        let field = name;
+        let iface = *interface;
+        interface
+            .rml_ui()
+            .element_add_event_listener(element, "dragend", false, move || {
+                let _ = iface
+                    .rml_ui()
+                    .context_set_pointer_capture(context, 0, 0, false);
+                queue.borrow_mut().push(InteractionEvent::DragEnd {
+                    field: field.clone(),
+                });
+            })?;
+    }
+    Ok(())
+}
+
 // ── DOM helpers ────────────────────────────────────────────────────
 
 pub(crate) use crate::sbc::rml::{element_by_id, escape_rml};
@@ -298,3 +445,32 @@ pub trait Field {
     /// End edit mode — switch back to display, without committing.
     fn end_edit(&mut self, _interface: &NativeInterfaceRef) {}
 }
+
+/// RmlUi event positions use top-origin screen coordinates; engine mouse and
+/// `warp_mouse` use the bottom-origin coordinates exposed by Spring's native
+/// input API.
+fn current_rml_mouse_position(interface: &NativeInterfaceRef) -> Option<(i32, i32)> {
+    let rml = interface.rml_ui();
+    let (event, ..) = rml.event_get_current().ok()?;
+    let (x, has_x) = rml.event_get_parameter_int(event, "mouse_x").ok()?;
+    let (y, has_y) = rml.event_get_parameter_int(event, "mouse_y").ok()?;
+    if !has_x || !has_y {
+        return None;
+    }
+    Some((x, y))
+}
+
+/// RmlUi mouse buttons are zero-based: left, right, then middle.
+fn current_rml_mouse_button(interface: &NativeInterfaceRef) -> Option<i32> {
+    let rml = interface.rml_ui();
+    let (event, ..) = rml.event_get_current().ok()?;
+    let (button, found) = rml.event_get_parameter_int(event, "button").ok()?;
+    found.then_some(button)
+}
+
+/// Convert an RmlUi top-origin event position for Spring's bottom-origin mouse
+/// API. The relative Rml capture itself retains top-origin coordinates.
+fn engine_mouse_position(interface: &NativeInterfaceRef, x: i32, y: i32) -> Option<(i32, i32)> {
+    let geometry = interface.display().get_view_geometry().ok()?;
+    Some((x, geometry.viewSizeY - y - 1))
+}

native/src/sbc/panels/fields/color.rs

@@ -4,8 +4,8 @@ use spring_native::{
 };
 
 use crate::sbc::panels::field::{
-    element_by_id, escape_rml, on_change, on_pointer, ChangeQueue, Field, FieldValue,
-    InteractionQueue,
+    element_by_id, escape_rml, on_change, on_numeric_pointer, on_pointer, ChangeQueue, Field,
+    FieldValue, InteractionQueue,
 };
 
 const CHANNEL_STEP: f32 = 0.005; // 1/200 per pixel, matches original
@@ -272,11 +272,14 @@ impl Field for ColorField {
             on_change(interface, e, format!("{}-hex", self.name), changes)?;
         }
         // Each channel: drag + edit
+        let (context, has_context) = interface.rml_ui().document_get_context(document)?;
         for (i, ch) in ['r', 'g', 'b'].iter().enumerate() {
             let sub_name = format!("{}-{ch}", self.name);
             if let Some(e) = element_by_id(interface, document, &format!("field-{n}-{ch}-display"))
             {
-                on_pointer(interface, e, sub_name.clone(), interactions)?;
+                if has_context {
+                    on_numeric_pointer(interface, context, e, sub_name.clone(), interactions)?;
+                }
             }
             if let Some(e) = self.channels[i].edit {
                 on_change(interface, e, sub_name, changes)?;