Keyboard Shortcuts: several keys for one command (#6273) (#6288)

* Keyboard shortcuts: a command can have several keys

Click a key on the Keyboard Shortcuts page to replace it, or the + after it
to add another; every key runs the command and menus show the first. One
key is still saved as a string, several as a list. Taking a key over from
another command leaves that command its other keys. ui.shortcut takes a
slot and reports every key.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Keyboard shortcuts: follow main's search layout; fix prefs test for key lists

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: bherbruck <brennen.herbruck@gmail.com>
This commit is contained in:
authored and GitHub committed 2026-10-29 12:32:19 +00:00
1 parent 00f9243c0d
commit 07d692ee0d
5 files changed
+218 -71

No files matched your search

+6 -4
View File
@@ -31,7 +31,7 @@
//! `ui.rename {text?, commit?}` finishes the rename box
//! - `ui.window {action: minimize|maximize|restore|toggle|close}`: what the title bar's buttons do
//! - `ui.confirm {accept?}`: the Delete confirmation (without `accept`: what it lists)
//! - `ui.shortcut {command, key?, replace?}`: a command's key, or bind one ("" clears)
//! - `ui.shortcut {command, key?, slot?, replace?}`: a command's keys, or bind one ("" clears)
//! - `ui.help {item?: about|shortcuts|report}`: the Help menu; returns the version and diagnostics
//! - `ui.prefs {...}`: the preferences (default_units, nav, zoom_reverse, orbit_around, msaa,
//! length_decimals, angle_decimals); returns them all
@@ -1022,12 +1022,14 @@ fn dispatch(app: &mut SolveApp, ctx: &egui::Context, method: &str, p: &Value) ->
},
"ui.shortcut" => {
let Some(id) = s("command") else { return err("missing `command`") };
let slot = p.get("slot").and_then(Value::as_u64).map(|n| usize::try_from(n).unwrap_or(usize::MAX));
let report = |app: &SolveApp| ok(json!({"command": id, "key": crate::keymap::effective(app, id), "keys": crate::keymap::keys(app, id)}));
match s("key") {
Some(k) => match crate::keymap::bind(app, id, k, b("replace")) {
Ok(()) => ok(json!({"command": id, "key": crate::keymap::effective(app, id)})),
Some(k) => match crate::keymap::bind_at(app, id, slot, k, b("replace")) {
Ok(()) => report(app),
Err(e) => err(e),
},
None => ok(json!({"command": id, "key": crate::keymap::effective(app, id)})),
None => report(app),
}
}
"ui.browser" => ok(json!({
+205 -62
View File
@@ -1,5 +1,5 @@
//! Keyboard shortcuts: every command's default key comes from its `CommandSpec`; the user can
//! rebind or clear any of them (Preferences › Keyboard Shortcuts). A new key that another command
//! rebind or clear any of them, or give one several keys (Preferences › Keyboard Shortcuts). A new key that another command
//! already uses is reported and only taken over on request; keys the app itself handles (Esc, S,
//! V, Delete, Ctrl+Z…) can't be bound. Changes are kept between runs.
@@ -48,10 +48,14 @@ pub const RESERVED: &[&str] = &[
"Ctrl+8",
];
/// The most keys one command keeps; more from a settings file are dropped.
const MAX_KEYS: usize = 8;
#[derive(Default)]
pub struct Keymap {
/// Command id → key (`""`: no key). Only the changed ones.
pub custom: BTreeMap<String, String>,
/// Command id → its keys, the first one shown in menus and tooltips (none: no key). Only the
/// changed ones.
pub custom: BTreeMap<String, Vec<String>>,
/// Asks for the Keyboard Shortcuts page of Preferences (File and Help menus).
pub open: bool,
/// Opened from Help: a list to read, not to edit.
@@ -59,9 +63,11 @@ pub struct Keymap {
filter: String,
/// The command waiting for a key press.
capturing: Option<String>,
/// Which of its keys the press replaces; one past the last adds a key.
slot: usize,
recorder: Recorder,
/// A key that another command uses: (command, key, the other commands).
conflict: Option<(String, String, Vec<String>)>,
/// A key that another command uses: (command, key, its slot, the other commands).
conflict: Option<(String, String, usize, Vec<String>)>,
message: Option<String>,
}
@@ -172,15 +178,28 @@ impl Recorder {
}
impl Keymap {
/// One key is saved as a string, as before a command could have several, so older versions
/// still read it.
pub fn prefs(&self) -> Value {
json!(self.custom)
Value::Object(
self.custom
.iter()
.map(|(id, keys)| {
let v = match keys.as_slice() {
[] => json!(""),
[key] => json!(key),
_ => json!(keys),
};
(id.clone(), v)
})
.collect(),
)
}
pub fn load(&mut self, v: &Value) {
self.custom =
v.as_object().map(|o| o.iter().take(2000).filter_map(|(k, v)| Some((k.clone(), v.as_str()?.to_string()))).collect()).unwrap_or_default();
// A shortcut that named a modifier key twice ("Shift+ShiftLeft", from before the shift
self.custom = v.as_object().map(|o| o.iter().take(2000).filter_map(|(k, v)| Some((k.clone(), saved_keys(v)?))).collect()).unwrap_or_default();
// A shortcut that named a modifier key twice ("Shift+ShiftLeft", before shift
// keys were named after themselves) is the modifier itself (#4582).
for key in self.custom.values_mut() {
for key in self.custom.values_mut().flatten() {
if let Some(named) = named_modifier_key(key) {
*key = named;
}
@@ -188,6 +207,16 @@ impl Keymap {
}
}
/// A command's saved keys: `""` (none), one key, or a list of them.
fn saved_keys(v: &Value) -> Option<Vec<String>> {
match v {
Value::String(key) if key.is_empty() => Some(Vec::new()),
Value::String(key) => Some(vec![key.clone()]),
Value::Array(keys) => Some(keys.iter().filter_map(Value::as_str).filter(|k| !k.is_empty()).take(MAX_KEYS).map(str::to_string).collect()),
_ => None,
}
}
/// A key press as a shortcut name: `E`, `Shift+E`, `Ctrl+Alt+K`, `F5`, `Delete`.
///
/// A modifier key is the shortcut itself, and its two sides are the same shortcut (the app's
@@ -277,18 +306,25 @@ fn named_modifier_key(key: &str) -> Option<String> {
Some(parts.join("+"))
}
/// The key a command runs from now.
/// The key a command runs from now, the one menus and tooltips show: its first.
pub fn effective(app: &SolveApp, id: &str) -> Option<String> {
keys(app, id).into_iter().next()
}
/// Every key a command runs from now.
pub fn keys(app: &SolveApp, id: &str) -> Vec<String> {
match app.keymap.custom.get(id) {
Some(k) if k.is_empty() => None,
Some(k) => Some(k.clone()),
None => solidcraft_engine::find_command(id).and_then(|c| c.shortcut).map(str::to_string),
Some(keys) => keys.clone(),
None => solidcraft_engine::find_command(id).and_then(|c| c.shortcut).filter(|k| !k.is_empty()).map(str::to_string).into_iter().collect(),
}
}
/// Use the spec already available when walking the command list.
fn effective_for_spec<'a>(app: &'a SolveApp, command: &CommandSpec) -> Option<&'a str> {
app.keymap.custom.get(command.id).map(String::as_str).or(command.shortcut).filter(|key| !key.is_empty())
fn keys_for_spec<'a>(app: &'a SolveApp, command: &CommandSpec) -> Vec<&'a str> {
match app.keymap.custom.get(command.id) {
Some(keys) => keys.iter().map(String::as_str).collect(),
None => command.shortcut.filter(|k| !k.is_empty()).into_iter().collect(),
}
}
/// Presentation only: stored Ctrl bindings retain their historical primary-modifier alias.
@@ -315,7 +351,7 @@ pub fn display_for(app: &SolveApp, id: &str) -> Option<String> {
/// Commands bound to `key` now.
pub fn commands_for(app: &SolveApp, key: &str) -> Vec<&'static str> {
command_specs().into_iter().filter(|c| effective(app, c.id).as_deref() == Some(key)).map(|c| c.id).collect()
command_specs().into_iter().filter(|c| keys_for_spec(app, c).contains(&key)).map(|c| c.id).collect()
}
/// Where a command's shortcut works: in a sketch (the SKETCH tab's tools), in the model (the
@@ -417,14 +453,24 @@ fn sketch_tool_for(app: &SolveApp, key: &str) -> Option<&'static str> {
})
}
/// Bind `key` to a command (`""` clears it). Refused for reserved keys, and when other commands
/// use the key unless `replace` (they lose it). A sketch tool and a model command may share a
/// key: each runs in its own mode.
/// Make `key` a command's only key (`""` clears its keys). See [`bind_at`].
pub fn bind(app: &mut SolveApp, id: &str, key: &str, replace: bool) -> Result<(), String> {
bind_at(app, id, None, key, replace)
}
/// Give a command `key`: as its only key (`slot` `None`), or in place of its key at `slot` (one
/// past the last adds a key; `""` there removes that key). Refused for reserved keys, and when
/// other commands use the key unless `replace` (they lose that key and keep their others). A
/// sketch tool and a model command may share a key: each runs in its own mode.
pub fn bind_at(app: &mut SolveApp, id: &str, slot: Option<usize>, key: &str, replace: bool) -> Result<(), String> {
let spec = solidcraft_engine::find_command(id).ok_or_else(|| format!("no command `{id}`"))?;
if RESERVED.contains(&key) {
return Err(format!("{key} is used by SolidCraft itself"));
}
let mut list = keys(app, id);
if slot.is_some_and(|n| n >= list.len()) && list.len() >= MAX_KEYS {
return Err(format!("a command has at most {MAX_KEYS} keys"));
}
if !key.is_empty() {
let others: Vec<&'static str> = commands_for(app, key).into_iter().filter(|o| *o != id && clash(o, id)).collect();
if !others.is_empty() && !replace {
@@ -432,15 +478,37 @@ pub fn bind(app: &mut SolveApp, id: &str, key: &str, replace: bool) -> Result<()
return Err(format!("{key} is already used by {}", names.join(", ")));
}
for o in others {
app.keymap.custom.insert(o.to_string(), String::new());
let mut theirs = keys(app, o);
theirs.retain(|k| k != key);
set_keys(app, o, theirs);
}
}
if spec.shortcut.unwrap_or("") == key {
match slot {
None => list = vec![key.to_string()],
Some(n) if n < list.len() && key.is_empty() => drop(list.remove(n)),
Some(n) => match list.get_mut(n) {
Some(old) => *old = key.to_string(),
None => list.push(key.to_string()),
},
}
let mut unique: Vec<String> = Vec::new();
for k in list {
if !k.is_empty() && !unique.contains(&k) {
unique.push(k);
}
}
set_keys(app, spec.id, unique);
Ok(())
}
/// Keep a command's keys, as a change only when they aren't its default.
fn set_keys(app: &mut SolveApp, id: &str, keys: Vec<String>) {
let default = solidcraft_engine::find_command(id).and_then(|c| c.shortcut).filter(|k| !k.is_empty());
if keys.iter().map(String::as_str).eq(default) {
app.keymap.custom.remove(id);
} else {
app.keymap.custom.insert(id.to_string(), key.to_string());
app.keymap.custom.insert(id.to_string(), keys);
}
Ok(())
}
pub fn reset(app: &mut SolveApp, id: Option<&str>) {
@@ -481,10 +549,12 @@ pub fn page(app: &mut SolveApp, ui: &mut egui::Ui) {
}
Recording::Complete(name) => {
app.keymap.capturing = None;
match bind(app, &id, &name, false) {
let slot = app.keymap.slot;
match bind_at(app, &id, Some(slot), &name, false) {
Ok(()) => app.keymap.message = None,
Err(e) if e.contains("already used") => {
app.keymap.conflict = Some((id.clone(), name.clone(), commands_for(app, &name).iter().map(|s| s.to_string()).collect()));
app.keymap.conflict =
Some((id.clone(), name.clone(), slot, commands_for(app, &name).iter().map(|s| s.to_string()).collect()));
app.keymap.message = Some(e);
}
Err(e) => app.keymap.message = Some(e),
@@ -535,12 +605,12 @@ pub fn page(app: &mut SolveApp, ui: &mut egui::Ui) {
if let Some(m) = &app.keymap.message {
ui_kit::text(ui, m, ui_kit::Text::Report("keymap_message", true));
}
if let Some((id, key, _)) = app.keymap.conflict.clone() {
if let Some((_, key, _, _)) = app.keymap.conflict.clone() {
ui.horizontal_wrapped(|ui| {
let replace = ui_kit::button(ui, crate::i18n::format("keymap.use_anyway", &[("key", &display(&key))]), ui_kit::Button::Normal);
crate::scenario::publish_target("keymap:replace", replace.rect);
if replace.clicked() {
action = Some((format!("{id}\n{key}"), "replace"));
action = Some((String::new(), "replace"));
}
if ui_kit::button(ui, app.tr_label("Cancel"), ui_kit::Button::Normal).clicked() {
action = Some((String::new(), "cancel"));
@@ -560,14 +630,14 @@ pub fn page(app: &mut SolveApp, ui: &mut egui::Ui) {
let commands: Vec<_> = command_specs()
.into_iter()
.filter_map(|c| {
let key = effective_for_spec(app, c).unwrap_or_default();
let keys = keys_for_spec(app, c);
let label = app.tr_label(c.label);
let hit = if filtering {
crate::prefs_search::matches_text(&q, &[c.label, c.id, key, label])
crate::prefs_search::matches_text(&q, &[c.label, c.id, label].into_iter().chain(keys.iter().copied()).collect::<Vec<_>>())
} else {
q.is_empty() || [c.label, c.id, key, label].iter().any(|s| s.to_lowercase().contains(&q))
q.is_empty() || [c.label, c.id, label].iter().chain(&keys).any(|s| s.to_lowercase().contains(&q))
};
hit.then_some((c, key, label))
hit.then_some((c, keys, label))
})
.collect();
if filtering && commands.is_empty() {
@@ -577,9 +647,10 @@ pub fn page(app: &mut SolveApp, ui: &mut egui::Ui) {
let shortcut_title = app.tr("prefs.shortcuts").to_string();
let paint = |ui: &mut egui::Ui| {
let t = crate::theme::Tokens::get();
let spacing = ui.spacing().item_spacing.x;
let key_width = commands
.iter()
.map(|(_, key, _)| ui_kit::ContentWidth::button(ui, &display(key)))
.map(|(_, keys, _)| keys.iter().map(|key| ui_kit::ContentWidth::button(ui, &display(key)) + spacing).sum::<f32>() + t.control_height)
.chain(app.keymap.recorder.preview().filter(|_| app.keymap.capturing.is_some()).map(|text| ui_kit::ContentWidth::button(ui, &text)))
.fold(ui_kit::ContentWidth::button(ui, app.tr_label("press a key…")), f32::max)
.max(ui_kit::ContentWidth::label(ui, app.tr_label("Keyboard Shortcuts")) + t.space_8);
@@ -595,7 +666,7 @@ pub fn page(app: &mut SolveApp, ui: &mut egui::Ui) {
ui_kit::Column::new("", 0.0).icon_only().min_content_width(action_width),
];
ui_kit::table(ui, "keymap", &columns, crate::i18n::tr("keymap.empty"), |ui, table| {
for (c, key, translated_label) in commands {
for (c, keys, translated_label) in commands {
table.row_visible(ui, c.id, app.keymap.capturing.as_deref() == Some(c.id), false, |row| {
row.cell(|ui| {
ui_kit::text(ui, translated_label, ui_kit::Text::Cell);
@@ -605,37 +676,45 @@ pub fn page(app: &mut SolveApp, ui: &mut egui::Ui) {
});
let capturing = app.keymap.capturing.as_deref() == Some(c.id);
let changed = app.keymap.custom.contains_key(c.id);
let text = if capturing {
app.keymap.recorder.preview().unwrap_or_else(|| app.tr_label("press a key…").to_string())
} else if key.is_empty() {
"—".to_string()
} else {
display(key)
};
row.cell(|ui| {
if app.keymap.read_only {
ui_kit::text(ui, &text, ui_kit::Text::Cell);
} else {
let capture = if key.is_empty() && !capturing {
let (rect, _) = ui.allocate_exact_size(egui::vec2(t.control_height, t.control_height), egui::Sense::hover());
ui_kit::quiet_icon_button_at(ui, rect, "plus", app.tr_label("Click, then press the new key"))
let text = if keys.is_empty() {
"—".to_string()
} else {
ui_kit::button(ui, &text, ui_kit::Button::Normal).on_hover_text(app.tr_label("Click, then press the new key"))
keys.iter().map(|key| display(key)).collect::<Vec<_>>().join(", ")
};
crate::scenario::publish_target(&format!("keymap:capture:{}", c.id), capture.rect);
if ui.is_rect_visible(capture.rect) {
crate::scenario::publish_handle(&format!("shortcut:{}", c.id), capture.rect.center());
}
if capture.clicked() {
capture.surrender_focus();
action = Some((c.id.to_string(), "capture"));
}
ui_kit::text(ui, &text, ui_kit::Text::Cell);
return;
}
let tip = app.tr_label("Click, then press the new key");
ui.horizontal(|ui| {
// Each key replaces itself when clicked; the last slot adds one.
for slot in 0..=keys.len() {
let capture = if capturing && app.keymap.slot == slot {
let text = app.keymap.recorder.preview().unwrap_or_else(|| app.tr_label("press a key…").to_string());
ui_kit::button(ui, &text, ui_kit::Button::Normal).on_hover_text(tip)
} else if let Some(key) = keys.get(slot) {
ui_kit::button(ui, display(key), ui_kit::Button::Normal).on_hover_text(tip)
} else {
let (rect, _) = ui.allocate_exact_size(egui::vec2(t.control_height, t.control_height), egui::Sense::hover());
ui_kit::quiet_icon_button_at(ui, rect, "plus", tip)
};
let name = if slot == 0 { c.id.to_string() } else { format!("{}:{slot}", c.id) };
crate::scenario::publish_target(&format!("keymap:capture:{name}"), capture.rect);
if ui.is_rect_visible(capture.rect) {
crate::scenario::publish_handle(&format!("shortcut:{name}"), capture.rect.center());
}
if capture.clicked() {
capture.surrender_focus();
action = Some((format!("{}\n{slot}", c.id), "capture"));
}
}
});
});
row.cell(|ui| {
if !app.keymap.read_only {
ui.horizontal(|ui| {
let clear = ui_kit::button(ui, app.tr_label("Clear"), ui_kit::Button::Enabled(!key.is_empty()));
let clear = ui_kit::button(ui, app.tr_label("Clear"), ui_kit::Button::Enabled(!keys.is_empty()));
crate::scenario::publish_target(&format!("keymap:clear:{}", c.id), clear.rect);
if clear.clicked() {
action = Some((c.id.to_string(), "clear"));
@@ -664,8 +743,10 @@ pub fn page(app: &mut SolveApp, ui: &mut egui::Ui) {
app.keymap.recorder = Recorder::default();
}
match action {
Some((id, "capture")) => {
app.keymap.capturing = Some(id);
Some((pair, "capture")) => {
let (id, slot) = pair.split_once('\n').unwrap_or((&pair, "0"));
app.keymap.slot = slot.parse().unwrap_or(0);
app.keymap.capturing = Some(id.to_string());
app.keymap.recorder = Recorder::default();
app.keymap.conflict = None;
app.keymap.message = None;
@@ -693,9 +774,9 @@ pub fn page(app: &mut SolveApp, ui: &mut egui::Ui) {
app.keymap.message = r.err().map(|e| format!("import: {e}"));
});
}
Some((pair, "replace")) => {
if let Some((id, key)) = pair.split_once('\n') {
let _ = bind(app, id, key, true);
Some((_, "replace")) => {
if let Some((id, key, slot, _)) = app.keymap.conflict.take() {
let _ = bind_at(app, &id, Some(slot), &key, true);
}
app.keymap.conflict = None;
app.keymap.message = None;
@@ -909,7 +990,7 @@ mod tests {
recorder_frame(&mut a, &ctx, 0.0, vec![event(egui::Key::M, true, egui::Modifiers::NONE), event(egui::Key::M, false, egui::Modifiers::NONE)]);
assert!(a.keymap.conflict.is_none());
recorder_frame(&mut a, &ctx, 1.1, vec![]);
assert_eq!(a.keymap.conflict.as_ref().map(|(_, key, _)| key.as_str()), Some("M"));
assert_eq!(a.keymap.conflict.as_ref().map(|(_, key, _, _)| key.as_str()), Some("M"));
assert_eq!(effective(&a, "solid.move").as_deref(), Some("M"));
assert_eq!(effective(&a, "solid.chamfer"), None);
stop_capture(&mut a);
@@ -1052,6 +1133,68 @@ mod tests {
assert_eq!(key_name(egui::Key::K, egui::Modifiers { ctrl: true, shift: true, ..Default::default() }), "Ctrl+Shift+K");
}
/// A command can run from several keys: the first is the one menus show, a key another
/// command takes over leaves its other keys, and one key is saved as before.
#[test]
fn a_command_runs_from_several_keys() {
let mut a = app();
bind_at(&mut a, "solid.extrude", Some(1), "Shift+J", false).unwrap();
assert_eq!(keys(&a, "solid.extrude"), ["E", "Shift+J"]);
assert_eq!(effective(&a, "solid.extrude").as_deref(), Some("E"), "the first key is shown");
assert_eq!(commands_for(&a, "E"), vec!["solid.extrude"]);
assert_eq!(commands_for(&a, "Shift+J"), vec!["solid.extrude"]);
bind_at(&mut a, "solid.extrude", Some(5), "Shift+J", false).unwrap();
assert_eq!(keys(&a, "solid.extrude"), ["E", "Shift+J"], "a key is kept once");
assert!(bind_at(&mut a, "solid.extrude", Some(2), "M", false).is_err(), "Move/Copy's key");
// Taking a key over leaves the other command its other keys.
bind_at(&mut a, "solid.revolve", None, "Shift+J", true).unwrap();
assert_eq!(keys(&a, "solid.extrude"), ["E"]);
assert!(!a.keymap.custom.contains_key("solid.extrude"), "back to its default");
// Saved as a list, and one key as a string.
bind_at(&mut a, "solid.extrude", Some(1), "Shift+K", false).unwrap();
let saved = a.keymap.prefs();
assert_eq!(saved["solid.extrude"], json!(["E", "Shift+K"]));
assert_eq!(saved["solid.revolve"], json!("Shift+J"));
let mut b = app();
b.keymap.load(&saved);
assert_eq!(keys(&b, "solid.extrude"), ["E", "Shift+K"]);
// A legacy modifier name in a list is renamed, as in a single key (#4582).
let mut c = app();
c.keymap.load(&json!({"solid.extrude": ["E", "Ctrl+ShiftLeft"]}));
assert_eq!(keys(&c, "solid.extrude"), ["E", "Ctrl+Shift"]);
// `""` at a slot removes that key; without one it clears them all.
bind_at(&mut b, "solid.extrude", Some(0), "", false).unwrap();
assert_eq!(keys(&b, "solid.extrude"), ["Shift+K"]);
bind(&mut b, "solid.extrude", "", false).unwrap();
assert!(keys(&b, "solid.extrude").is_empty());
assert_eq!(b.keymap.prefs()["solid.extrude"], json!(""));
// A hostile settings file can't give one command endless keys.
let many: Vec<String> = (0..50).map(|n| format!("Ctrl+Alt+F{n}")).collect();
b.keymap.load(&json!({"solid.extrude": many}));
assert_eq!(keys(&b, "solid.extrude").len(), MAX_KEYS);
assert!(bind_at(&mut b, "solid.extrude", Some(MAX_KEYS), "Shift+L", false).is_err());
}
/// On the page: the + after a command's key records one more, and both keys run it.
#[test]
fn the_shortcuts_page_adds_a_second_key() {
let mut h = crate::scenario::Harness::new();
h.app.home.open = false;
h.call("ui.prefs", json!({"open":"Keyboard Shortcuts"}));
h.step(&json!({"click":{"handle":"shortcut:filter"}})).unwrap();
h.call("ui.text", json!({"text":"solid.extrude"}));
h.frames(2);
h.step(&json!({"click":{"handle":"shortcut:solid.extrude:1"}})).unwrap();
assert_eq!(h.app.keymap.capturing.as_deref(), Some("solid.extrude"));
h.call("ui.key", json!({"key":"J","pressed":true,"shift":true}));
h.call("ui.key", json!({"key":"J","pressed":false}));
h.frames(65);
assert_eq!(keys(&h.app, "solid.extrude"), ["E", "Shift+J"]);
assert!(h.widget("E").is_some() && h.widget("Shift+J").is_some(), "both keys are listed");
let got = h.call("ui.shortcut", json!({"command":"solid.extrude"}));
assert_eq!(got["result"]["keys"], json!(["E", "Shift+J"]), "{got}");
}
/// #4163: one key for a model command and a sketch tool. Binding it to both is allowed (a
/// second model command still clashes); outside a sketch it runs the model command, in a
/// sketch the tool.
+3 -3
View File
@@ -1361,7 +1361,7 @@ struct Snapshot {
agent: crate::agent_cursor::Settings,
autosave: f64,
auto_project: bool,
keys: std::collections::BTreeMap<String, String>,
keys: std::collections::BTreeMap<String, Vec<String>>,
}
impl Snapshot {
@@ -6074,7 +6074,7 @@ mod tests {
assert!(app.prefs_window.open && app.prefs_window.section == 0);
control(&mut app, &json!({"theme": "light", "ui_scale": 1.25, "zoom_to_cursor": false})).unwrap();
assert!(!app.ui.dark, "light applies at once");
app.keymap.custom.insert("solid.extrude".into(), "Shift+E".into());
app.keymap.custom.insert("solid.extrude".into(), vec!["Shift+E".into()]);
let v = control(&mut app, &json!({"button": "cancel"})).unwrap();
assert_eq!(v["dialog"], serde_json::Value::Null);
assert!(app.ui.dark && app.preferences.theme == "dark" && app.preferences.ui_scale == 1.0 && app.preferences.zoom_to_cursor);
@@ -6154,7 +6154,7 @@ mod tests {
// update bookkeeping (not a setting, and Cancel keeps it) does not.
app.preferences.update.last_check += 1.0;
assert_eq!(draw(&mut app, vec![]), Some(0.0), "update bookkeeping is not a change");
app.keymap.custom.insert("solid.extrude".into(), "Shift+E".into());
app.keymap.custom.insert("solid.extrude".into(), vec!["Shift+E".into()]);
assert_eq!(draw(&mut app, vec![]), Some(1.0), "a rebinding is a change");
let v = control(&mut app, &json!({"button": "apply"})).unwrap();
assert_eq!(v["apply_enabled"], false);
+3 -1
View File
@@ -1,6 +1,8 @@
# Keyboard shortcuts
Command shortcuts can be changed in File › Keyboard Shortcuts; these are the defaults.
Command shortcuts can be changed in File › Keyboard Shortcuts; these are the defaults. Click a
key to replace it, or the **+** after it to give the command another key: every key it has
runs it, and menus and tooltips show the first one.
Click a binding to record a new shortcut. A shortcut can contain Shift, Ctrl/Cmd and
Alt/Option modifiers plus exactly one other key. Hold the modifiers, then press the final
+1 -1
View File
@@ -317,7 +317,7 @@ labels; `prefs:measure_axis_distances` identifies the checkbox.
| `ui.documents` | `action?`: `new`, `switch`, `close`, `quit`; `index?`; `force?` (close without asking); `answer?`: `save`, `dont_save`, `cancel` (answers "save changes?"); `open_elsewhere?`: `read_only`, `anyway`, `cancel` (answers "open elsewhere" for the first Open waiting); `changed_on_disk?`: `save_copy`, `overwrite`, `cancel` (answers "changed on disk" before a Save) | the open designs (tabs): names, unsaved flags, the active one, a pending "save changes?" prompt, whether a quit is asking, whether the active design is `read_only`, the Opens waiting for "open elsewhere" (`open_elsewhere`) and a waiting "changed on disk" (`changed_on_disk`) |
| `ui.file` | `path`; `insert?`: bool | starts an interactive background Open or Insert; poll `ui.inspect.file_busy` for completion; the window stays responsive |
| `ui.home` | `open?`: bool; `sample?`: index | the start page: show or hide it, open a built-in sample (once built); returns `open` and the recent designs |
| `ui.shortcut` | `command`, `key?`, `replace?` | a command's key, or rebinds it (`""` clears; a key another command uses is refused unless `replace`) |
| `ui.shortcut` | `command`, `key?`, `slot?`, `replace?` | a command's keys (`key`: the first, shown in menus; `keys`: all), or rebinds it: `key` becomes its only key, or with `slot` replaces its key there (one past the last adds a key, `""` there removes that key); `""` without `slot` clears them; a key another command uses is refused unless `replace` |
| `ui.help` | `item?`: `about`, `shortcuts` (read only), `report` (opens a report draft for review), `crashes` (the Crash Reports window) | the version, commit, build date and diagnostic text |
| `ui.prefs` | any of the [`ui.prefs` settings](#uiprefs-settings) below; also `open`, `button` and `stand_up` (listed there) | sets preferences (kept between runs), returns them all plus `dialog` (the open page or null), `apply_enabled` (whether the dialog's Apply has a change to keep), `dark`, `viewport_dark` (whether the 3D view is dark), `stand_up_offer` (the offered bodies, or null), `stand_up_note` (whether that offer is the note), `theme_followed` and `theme_follow_error` |
| `ui.capture` | `action?`: `capture`, `revert`, `cancel` | answers the Capture Position question (asked when a command starts or the design is saved while components were moved without capturing); without `action`, what waits |