2bc41aeb8602
selection_tools_toggle.rs
//! User-configurable persistent Selection / Direct Selection switching.
// Tests may unwrap/panic (AGENTS.md, Robustness).
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use std::sync::{Mutex, MutexGuard};
use egui::{Event, Key, Modifiers};
use serde_json::json;
use vectorcraft_doc::NodeId;
use vectorcraft_engine::Session;
use vectorcraft_geom::PathData;
use vectorcraft_ui_egui::{UiState, VectorcraftApp, i18n, shortcut_editor, shortcuts};
const SWITCH: &str = "tool.switchSelectionTools";
static CASE: Mutex<()> = Mutex::new(());
// Integration binaries use process-wide locale/keymap mirrors. Every case owns the guard,
// starts from the same neutral keymap, and restores that keymap even if an assertion fails.
struct Globals {
_lock: MutexGuard<'static, ()>,
language: i18n::Lang,
neutral: UiState,
}
impl Globals {
fn new() -> Self {
let lock = CASE.lock().unwrap_or_else(|e| e.into_inner());
let language = i18n::current();
let neutral = UiState::default();
i18n::set_current(i18n::Lang::EN);
shortcut_editor::sync(&neutral);
Self { _lock: lock, language, neutral }
}
}
impl Drop for Globals {
fn drop(&mut self) {
shortcut_editor::sync(&self.neutral);
i18n::set_current(self.language);
}
}
fn app() -> (VectorcraftApp, NodeId) {
let mut app = VectorcraftApp::new(Session::new(), Default::default());
app.run("file.new", json!({"width": 400, "height": 300, "profile": null})).unwrap();
let shape = app.run("shape.rectangle", json!({"x": 100, "y": 100, "width": 100, "height": 50})).unwrap();
let id = NodeId(shape["id"].as_u64().unwrap());
app.select_tool("selection");
shortcut_editor::sync(&app.ui);
(app, id)
}
fn path_state(app: &VectorcraftApp, id: NodeId) -> (PathData, Vec<NodeId>, usize) {
let state = app.session.doc().unwrap();
(state.doc.node(id).unwrap().path_data().unwrap().clone(), state.selection.objects.clone(), state.history.undo.len())
}
struct Keyboard {
ctx: egui::Context,
time: f64,
}
impl Keyboard {
fn new() -> Self {
Self { ctx: egui::Context::default(), time: 0.0 }
}
fn frame(&mut self, app: &mut VectorcraftApp, events: Vec<Event>) {
self.time += 0.05;
let mut out = self.ctx.run_ui(
egui::RawInput {
events,
time: Some(self.time),
focused: true,
screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(800.0, 600.0))),
..Default::default()
},
|ui| {
app.logic(ui.ctx());
shortcuts::handle(app, ui.ctx());
},
);
out.textures_delta.clear();
}
fn key(&mut self, app: &mut VectorcraftApp, key: Key, pressed: bool, modifiers: Modifiers) {
let mut events = vec![Event::ModifiersChanged(modifiers), Event::Key { key, physical_key: Some(key), pressed, repeat: false, modifiers }];
// Plain letter shortcuts read the text the native host pairs with the key press.
// Modified command chords and releases produce no text.
if pressed && modifiers == Modifiers::NONE {
match key {
Key::V => events.push(Event::Text("v".into())),
Key::A => events.push(Event::Text("a".into())),
_ => {}
}
}
self.frame(app, events);
}
fn tap(&mut self, app: &mut VectorcraftApp, key: Key, modifiers: Modifiers) {
self.key(app, key, true, modifiers);
self.key(app, key, false, modifiers);
self.frame(app, vec![Event::ModifiersChanged(Modifiers::NONE)]);
}
}
fn control() -> Modifiers {
// Physical Control is the requested chord. On Windows/Linux egui also calls it command.
Modifiers { ctrl: true, command: !cfg!(target_os = "macos"), ..Modifiers::NONE }
}
fn configure_control_backtick(app: &mut VectorcraftApp) {
// Main assigns this chord to Select Last Selection Tool. Free that binding explicitly,
// as a user does in Keyboard Shortcuts, before assigning the configurable toggle.
app.run("shortcuts.set", json!({"id": "tool.selectLastSelection", "shortcut": ""})).unwrap();
app.run("shortcuts.set", json!({"id": SWITCH, "shortcut": "Ctrl+~"})).unwrap();
}
#[test]
fn selection_tools_existing_v_and_a_defaults_keep_their_choices() {
let _globals = Globals::new();
let (mut app, id) = app();
let before = path_state(&app, id);
app.select_tool("pen");
let mut keys = Keyboard::new();
keys.tap(&mut app, Key::V, Modifiers::NONE);
assert_eq!(app.session.tool_id(), "selection");
keys.tap(&mut app, Key::A, Modifiers::NONE);
assert_eq!(app.session.tool_id(), "directSelection");
assert_eq!(path_state(&app, id), before);
}
#[test]
fn selection_tools_configured_control_backtick_toggles_both_arrows() {
let _globals = Globals::new();
let (mut app, id) = app();
let before = path_state(&app, id);
let rows = app.run("shortcuts.list", json!({"query": SWITCH})).unwrap();
let rows = rows.as_array().unwrap();
assert_eq!(rows.len(), 1, "the configurable command is missing: {rows:?}");
assert_eq!(rows[0]["id"], SWITCH);
assert_eq!(rows[0]["label"], "Switch Selection Tools");
assert!(rows[0]["default"].is_null());
assert!(rows[0]["shortcut"].is_null());
configure_control_backtick(&mut app);
let mut keys = Keyboard::new();
keys.tap(&mut app, Key::Backtick, control());
assert_eq!(app.session.tool_id(), "directSelection");
keys.tap(&mut app, Key::Backtick, control());
assert_eq!(app.session.tool_id(), "selection");
assert_eq!(path_state(&app, id), before, "idle tool choices preserve path, selection and history");
}
#[test]
fn selection_tools_saved_binding_runs_and_reset_removes_it() {
let _globals = Globals::new();
let (mut original, _) = app();
configure_control_backtick(&mut original);
let saved = serde_json::to_string(&original.ui).unwrap();
let (mut restored, id) = app();
restored.ui = serde_json::from_str::<UiState>(&saved).unwrap();
shortcut_editor::sync(&restored.ui);
let before = path_state(&restored, id);
let mut keys = Keyboard::new();
keys.tap(&mut restored, Key::Backtick, control());
assert_eq!(restored.session.tool_id(), "directSelection");
restored.run("shortcuts.set", json!({"id": SWITCH, "shortcut": null})).unwrap();
let rows = restored.run("shortcuts.list", json!({"query": SWITCH})).unwrap();
assert!(rows[0]["shortcut"].is_null());
assert_eq!(rows[0]["overridden"], false);
keys.tap(&mut restored, Key::Backtick, control());
assert_eq!(restored.session.tool_id(), "directSelection", "reset leaves this chord unbound");
assert_eq!(path_state(&restored, id), before);
}
#[test]
fn selection_tools_other_tools_enter_selection_and_explicit_choice_survives_release() {
let _globals = Globals::new();
let (mut app, id) = app();
let before = path_state(&app, id);
for third in ["pen", "groupSelection"] {
app.select_tool(third);
assert_eq!(app.run(SWITCH, json!({})).unwrap()["tool"], "selection");
assert_eq!(app.session.tool_id(), "selection");
assert_eq!(app.run(SWITCH, json!({})).unwrap()["tool"], "directSelection");
assert_eq!(app.session.tool_id(), "directSelection");
}
configure_control_backtick(&mut app);
app.select_tool("pen");
let mut keys = Keyboard::new();
keys.key(&mut app, Key::V, true, Modifiers::NONE);
assert_eq!(app.session.tool_id(), "selection");
keys.tap(&mut app, Key::Backtick, control());
assert_eq!(app.session.tool_id(), "directSelection");
// Keep V down longer than the existing 0.25s temporary-tool threshold. Without clearing
// the held choice, its release would restore Pen instead of respecting this command.
for _ in 0..6 {
keys.frame(&mut app, vec![]);
}
keys.key(&mut app, Key::V, false, Modifiers::NONE);
assert_eq!(app.session.tool_id(), "directSelection");
assert_eq!(path_state(&app, id), before);
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.