08fa042039
* claim: #2217 * Dialogs: drag a value's label sideways to change it (#2217) A value row's label (expr_row, hint_row) now scrubs a literal value: about a hundredth of its size per point of drag, on that step's grid, Shift ten times finer, Ctrl/Cmd ten times coarser. The unit and decimal mark stay as typed, a size never turns negative, and expressions and parameters are left alone. The text changes as if typed, so previews follow and OK still makes one command. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * Label drag: measure from the press point, cap values, keep scrub kit-private Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
1869 lines
90 KiB
Rust
1869 lines
90 KiB
Rust
//! Fields elements for dense cards; see `docs/ui-kit.md` for tokens and usage.
|
||
use super::{
|
||
layout::{label, publish},
|
||
metrics::*,
|
||
text::paint_text,
|
||
};
|
||
use crate::ui_kit::BackingTooltipExt as _;
|
||
use crate::ui_kit::{Container, Surface};
|
||
use crate::{scenario, theme::Tokens};
|
||
use egui::{Response, RichText, Ui, vec2};
|
||
|
||
/// One alignment policy for every kit text input. Align the galley itself rather than
|
||
/// approximating font metrics with integer margins (Plex Mono and Sans differ).
|
||
pub(super) fn text_input(edit: egui::TextEdit<'_>) -> egui::TextEdit<'_> {
|
||
let t = Tokens::get();
|
||
edit.vertical_align(egui::Align::Center).margin(vec2(t.form_inset, 0.0)).min_size(vec2(0.0, t.control_height))
|
||
}
|
||
|
||
/// Expression editor with the application's existing completion and number-focus behaviour.
|
||
/// Values carry their own unit text ("20 mm", "45 deg"): there is no unit suffix. Returns accepted Enter.
|
||
/// Tokens: `control_height, control_fill, form_inset, font_label, space_4; scope tokens`.
|
||
pub(crate) fn field(ui: &mut Ui, value: &mut String) -> bool {
|
||
editor(ui, value, "", true).0
|
||
}
|
||
|
||
/// Expression editor with empty-value hint. Tokens: `same as field`.
|
||
pub(crate) fn hint_field(ui: &mut Ui, value: &mut String, hint: &str) -> bool {
|
||
editor(ui, value, hint, true).0
|
||
}
|
||
|
||
/// [`hint_field`] for a value the form checks before it runs: `flagged`, it is outlined in the
|
||
/// warning colour (the caller says why in words under it, [`super::warning_caption`]). Returns
|
||
/// accepted Enter and the editor's response. Tokens: `same as field, warning`.
|
||
pub(crate) fn checked_field(ui: &mut Ui, value: &mut String, hint: &str, flagged: bool) -> (bool, Response) {
|
||
let (enter, _, response) = editor(ui, value, hint, true);
|
||
if flagged {
|
||
let t = Tokens::get();
|
||
ui.painter().rect_stroke(response.rect, t.control_radius, egui::Stroke::new(1.5, t.warning), egui::StrokeKind::Inside);
|
||
}
|
||
(enter, response)
|
||
}
|
||
|
||
/// The whole numbers a count field may hold, and how its text evaluates (parameters and
|
||
/// expressions included). `eval` returns None for text that is not a value.
|
||
pub(crate) struct Count<'a> {
|
||
pub min: i64,
|
||
pub max: i64,
|
||
pub eval: &'a dyn Fn(&str) -> Option<f64>,
|
||
}
|
||
|
||
/// Expression editor for a whole-number count (a pattern's quantity), with up and down step
|
||
/// arrows at its right edge. An arrow steps the evaluated count by one and stays within the
|
||
/// limits: a plain number is replaced, an expression keeps its parameters and gains or adjusts
|
||
/// a trailing `+ n`. The text changes as if typed, so previews follow. Returns accepted Enter.
|
||
/// Tokens: field tokens, `control_border`, `selected_bg`, `form_ink`, `form_dim`.
|
||
pub(crate) fn count_field(ui: &mut Ui, value: &mut String, limits: &Count<'_>) -> bool {
|
||
let t = Tokens::get();
|
||
let reserve = (t.control_height * 0.75).round();
|
||
let (enter, _, response) = editor_reserving(ui, value, "", true, reserve);
|
||
let rect = response.rect;
|
||
let column = egui::Rect::from_min_max(egui::pos2((rect.right() - reserve).max(rect.left()), rect.top()), rect.max);
|
||
let painter = ui.painter_at(rect);
|
||
painter.vline(column.left(), column.y_range().shrink(t.space_4), egui::Stroke::new(1.0, t.control_border));
|
||
let row = label(ui).to_owned();
|
||
for (delta, half, name) in [(1, column.split_top_bottom_at_fraction(0.5).0, "up"), (-1, column.split_top_bottom_at_fraction(0.5).1, "down")] {
|
||
let next = step_count(value, delta, limits);
|
||
let arrow = ui.interact(half, ui.id().with(("sc_count_step", &row, name)), egui::Sense::click());
|
||
let enabled = ui.is_enabled() && next.is_some();
|
||
// The arrows stand inside the editor, which claims the text cursor across its whole
|
||
// rect: they are not text, so each one takes the ordinary cursor back after it. The
|
||
// pointer is read from the rect rather than from the hover the editor competes for.
|
||
let over = ui.rect_contains_pointer(half);
|
||
if over {
|
||
ui.ctx().set_cursor_icon(egui::CursorIcon::Default);
|
||
}
|
||
if enabled && over {
|
||
painter.rect_filled(half.shrink(1.0), t.control_radius, t.selected_bg);
|
||
}
|
||
let ink = if enabled { t.form_ink } else { t.form_dim };
|
||
let (c, w, h) = (half.center(), (reserve * 0.18).max(2.0), (half.height() * 0.2).max(2.0));
|
||
let tip = if delta > 0 { -h } else { h };
|
||
painter.add(egui::Shape::convex_polygon(
|
||
vec![egui::pos2(c.x, c.y + tip * 0.5), egui::pos2(c.x + w, c.y - tip * 0.5), egui::pos2(c.x - w, c.y - tip * 0.5)],
|
||
ink,
|
||
egui::Stroke::NONE,
|
||
));
|
||
let sign = if delta > 0 { "+1" } else { "−1" };
|
||
arrow.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::Button, enabled, format!("{} {sign}", crate::i18n::tr_label(&row))));
|
||
scenario::publish_handle(&format!("dialog:{row} {name}"), half.center());
|
||
if let (true, true, Some(next)) = (enabled, arrow.clicked(), next) {
|
||
*value = next;
|
||
}
|
||
}
|
||
enter
|
||
}
|
||
|
||
/// `text` stepped by `delta` whole numbers within `limits`, or None when it does not evaluate
|
||
/// or the step would leave the limits. A typed number between whole numbers steps to the next
|
||
/// one; an expression that evaluates between them is left alone.
|
||
fn step_count(text: &str, delta: i64, limits: &Count<'_>) -> Option<String> {
|
||
const SAFE: f64 = 1e15;
|
||
let trimmed = text.trim();
|
||
let now = (limits.eval)(trimmed).filter(|v| v.is_finite() && v.abs() < SAFE)?;
|
||
let from = if delta > 0 { now.floor() } else { now.ceil() } as i64;
|
||
let target = from.saturating_add(delta).clamp(limits.min, limits.max);
|
||
let moves = if delta > 0 { target as f64 > now } else { (target as f64) < now };
|
||
if !moves {
|
||
return None;
|
||
}
|
||
if trimmed.parse::<f64>().is_ok() {
|
||
return Some(target.to_string());
|
||
}
|
||
// An expression: adjust its trailing `+ n` / `- n`, or add one, and check that it now says `target`.
|
||
let offset = |base: &str, n: i64| match n {
|
||
0 => base.to_owned(),
|
||
n if n > 0 => format!("{base} + {n}"),
|
||
n => format!("{base} - {}", n.unsigned_abs()),
|
||
};
|
||
let tail = trimmed.rfind(['+', '-']).and_then(|at| {
|
||
let (base, number) = (trimmed[..at].trim_end(), trimmed[at + 1..].trim());
|
||
let n: i64 = number.bytes().all(|b| b.is_ascii_digit()).then(|| number.parse().ok()).flatten()?;
|
||
let base_ok = !base.is_empty() && !base.ends_with(['+', '-', '*', '/', '^', '(', ',']);
|
||
base_ok.then(|| (base, if trimmed[at..].starts_with('-') { -n } else { n }))
|
||
});
|
||
let step = target - now.round() as i64;
|
||
let candidates =
|
||
[tail.map(|(base, n)| offset(base, n.saturating_add(step))), Some(offset(trimmed, step)), Some(offset(&format!("({trimmed})"), step))];
|
||
candidates.into_iter().flatten().find(|c| (limits.eval)(c).is_some_and(|v| (v - target as f64).abs() < 1e-9))
|
||
}
|
||
|
||
/// A value a label drag can change: a number with an optional unit ("20 mm", "1,5 in", "45°").
|
||
#[derive(Clone, Debug, PartialEq)]
|
||
struct Literal {
|
||
number: f64,
|
||
/// The text after the number, as written (" mm").
|
||
unit: String,
|
||
comma: bool,
|
||
}
|
||
|
||
/// The largest value a label drag reads or writes.
|
||
const LITERAL_CAP: f64 = 1e12;
|
||
|
||
/// `text` as a [`Literal`], or None for anything else: a parameter, a formula, an empty field.
|
||
/// Dragging never rewrites an expression, so a driving parameter stays driving.
|
||
fn literal(text: &str) -> Option<Literal> {
|
||
let text = text.trim();
|
||
if !solidcraft_engine::doc::expr::is_literal(text) {
|
||
return None;
|
||
}
|
||
let sign = usize::from(text.starts_with(['-', '+']));
|
||
let end = text.char_indices().skip(sign).find(|(_, c)| !(c.is_ascii_digit() || *c == '.' || *c == ',')).map_or(text.len(), |(at, _)| at);
|
||
let (number, unit) = (text.get(..end)?, text.get(end..)?);
|
||
// An exponent ("1e3") or anything else that is not a unit is left alone.
|
||
solidcraft_engine::doc::expr::unit_info(unit)?;
|
||
let comma = number.contains(',');
|
||
let number: f64 = number.replace(',', ".").parse().ok().filter(|n: &f64| n.is_finite() && n.abs() < LITERAL_CAP)?;
|
||
Some(Literal { number, unit: unit.to_owned(), comma })
|
||
}
|
||
|
||
/// How much one point of drag changes a value of this size, before Shift or Ctrl: about a
|
||
/// hundredth of it, as a power of ten, so 20 mm moves by 0.1 mm and 250 mm by 1 mm.
|
||
fn scrub_step(number: f64) -> f64 {
|
||
let decade = number.abs().max(1.0).log10().floor().clamp(0.0, 8.0);
|
||
10f64.powf(decade - 2.0)
|
||
}
|
||
|
||
/// `anchor` moved by `points` of drag at `step` per point, on the step's grid. A value that
|
||
/// starts at zero or above stays there: a drag never turns a size negative.
|
||
fn scrubbed(anchor: f64, points: f32, step: f64) -> f64 {
|
||
let moved = ((anchor + f64::from(points) * step) / step).round() * step;
|
||
let moved = if anchor >= 0.0 { moved.max(0.0) } else { moved };
|
||
// Literal values are capped where `literal` reads them; a drag never leaves that range.
|
||
if moved.is_finite() && moved.abs() < LITERAL_CAP { moved } else { anchor }
|
||
}
|
||
|
||
/// The scrubbed text: as many decimals as the step needs, the unit and decimal mark as typed.
|
||
fn scrub_text(number: f64, step: f64, literal: &Literal) -> String {
|
||
let decimals = (-step.log10()).ceil().clamp(0.0, 6.0) as usize;
|
||
let mut text = format!("{number:.decimals$}");
|
||
if text.starts_with('-') && text.trim_start_matches(['-', '0', '.']).is_empty() {
|
||
text.remove(0);
|
||
}
|
||
if literal.comma {
|
||
text = text.replace('.', ",");
|
||
}
|
||
text + &literal.unit
|
||
}
|
||
|
||
/// An ongoing label drag: the value and pointer x it is measured from, and the speed in use.
|
||
#[derive(Clone)]
|
||
struct Scrub {
|
||
anchor: f64,
|
||
origin: f32,
|
||
step: f64,
|
||
}
|
||
|
||
/// Dragging a row's label sideways changes the literal value in its field: Shift for a tenth of
|
||
/// the speed, Ctrl (Cmd on a Mac) for ten times. The text changes as if typed, so previews
|
||
/// follow, and the dialog's OK still makes the one command (and the one undo step). A field
|
||
/// holding an expression or a parameter is left alone. Returns whether the text changed.
|
||
pub(super) fn scrub(ui: &Ui, label: &Response, value: &mut String) -> bool {
|
||
let id = label.id.with("sc_scrub");
|
||
let Some(now) = literal(value).filter(|_| ui.is_enabled()) else {
|
||
ui.ctx().data_mut(|data| data.remove::<Scrub>(id));
|
||
return false;
|
||
};
|
||
if label.hovered() || label.dragged() {
|
||
ui.ctx().set_cursor_icon(egui::CursorIcon::ResizeHorizontal);
|
||
}
|
||
if !label.dragged() {
|
||
ui.ctx().data_mut(|data| data.remove::<Scrub>(id));
|
||
return false;
|
||
}
|
||
let factor = ui.input(|i| {
|
||
if i.modifiers.shift {
|
||
0.1
|
||
} else if i.modifiers.command {
|
||
10.0
|
||
} else {
|
||
1.0
|
||
}
|
||
});
|
||
// Measured from where the pointer is, not summed per frame, so no frame's jump is lost or doubled.
|
||
let (Some(x), Some(pressed)) = ui.input(|i| (i.pointer.latest_pos().map(|p| p.x), i.pointer.press_origin().map(|p| p.x))) else {
|
||
return false;
|
||
};
|
||
let base = ui.ctx().data(|data| data.get_temp::<Scrub>(id));
|
||
// A new drag starts from where it was pressed; a changed modifier starts over from here.
|
||
let state = match base {
|
||
Some(state) if (state.step - scrub_step(state.anchor) * factor).abs() <= state.step * 1e-9 => state,
|
||
Some(_) => Scrub { anchor: now.number, origin: x, step: scrub_step(now.number) * factor },
|
||
None => Scrub { anchor: now.number, origin: pressed, step: scrub_step(now.number) * factor },
|
||
};
|
||
let points = x - state.origin;
|
||
let text = scrub_text(scrubbed(state.anchor, if points.is_finite() { points } else { 0.0 }, state.step), state.step, &now);
|
||
ui.ctx().data_mut(|data| data.insert_temp(id, state));
|
||
if text == *value {
|
||
return false;
|
||
}
|
||
*value = text;
|
||
true
|
||
}
|
||
|
||
/// Names, thread designations and plain numeric counts do not accept expression completion.
|
||
/// Plain text editor without expression completion; returns (Enter, changed). Tokens: `same as field`.
|
||
pub(crate) fn text_field(ui: &mut Ui, value: &mut String, hint: &str) -> (bool, bool) {
|
||
let (enter, changed, _) = editor(ui, value, hint, false);
|
||
(enter, changed)
|
||
}
|
||
|
||
/// [`text_field`] with a tooltip; returns (Enter, changed). Tokens: `same as field`.
|
||
pub(crate) fn text_field_tip(ui: &mut Ui, value: &mut String, hint: &str, tip: &str) -> (bool, bool) {
|
||
let (enter, changed, response) = editor(ui, value, hint, false);
|
||
response.backing_on_hover_text(tip);
|
||
(enter, changed)
|
||
}
|
||
|
||
/// Expression field for a single-value popup which keeps ownership of keyboard focus.
|
||
/// Tokens: field tokens. Preserves the legacy Edit Dimension focus behavior.
|
||
pub(crate) fn focused_field(ui: &mut Ui, value: &mut String) -> bool {
|
||
let (enter, _, response) = editor(ui, value, "", true);
|
||
response.request_focus();
|
||
enter
|
||
}
|
||
|
||
/// Plain text editor which keeps keyboard focus (a name asked for in a one-field card); returns
|
||
/// accepted Enter. Tokens: `same as field`.
|
||
pub(crate) fn focused_text_field(ui: &mut Ui, value: &mut String, hint: &str) -> bool {
|
||
let (enter, _, response) = editor(ui, value, hint, false);
|
||
response.request_focus();
|
||
enter
|
||
}
|
||
|
||
/// Multiline plain text with a stable focus ID. The caller owns Enter/Shift+Enter routing.
|
||
/// Tokens: control_height, control_fill, form_inset and font_label.
|
||
pub(crate) fn multiline_text_field(ui: &mut Ui, label: &str, id: egui::Id, value: &mut String) -> Response {
|
||
super::layout::sized_row(ui, label, row_height() * 3.0, |ui| {
|
||
let t = Tokens::get();
|
||
let mut response = ui.add_sized(
|
||
vec2(dimension(ui.available_width()), row_height() * 3.0),
|
||
text_input(egui::TextEdit::multiline(value))
|
||
.id(id)
|
||
.desired_rows(3)
|
||
.font(egui::FontId::monospace(t.font_label))
|
||
.background_color(t.input_fill()),
|
||
);
|
||
super::text_menu::menu(ui, &mut response, value, super::text_menu::Field::LINES);
|
||
publish(ui, &response, egui::WidgetType::TextEdit);
|
||
response
|
||
})
|
||
}
|
||
|
||
/// Supplied entry in a searchable dropdown. Handles are optional stable application aliases.
|
||
pub(crate) struct SearchOption<'a> {
|
||
pub value: &'a str,
|
||
pub label: &'a str,
|
||
pub handle: Option<&'a str>,
|
||
}
|
||
|
||
/// Searchable dropdown with an optional custom-value action and loading message.
|
||
/// Returns a chosen value; callers keep domain-specific validation and discovery.
|
||
/// Tokens: control_height, space_24, font_label and scope control tokens.
|
||
pub(crate) fn searchable_dropdown(
|
||
ui: &mut Ui,
|
||
id: &str,
|
||
current: &str,
|
||
filter: &mut String,
|
||
options: &[SearchOption<'_>],
|
||
custom: Option<&str>,
|
||
pending: Option<&str>,
|
||
) -> Option<String> {
|
||
searchable_dropdown_with(ui, id, current, filter, options, SearchMenu { custom, pending, icon: None })
|
||
}
|
||
|
||
struct SearchMenu<'a> {
|
||
custom: Option<&'a str>,
|
||
pending: Option<&'a str>,
|
||
icon: Option<&'static str>,
|
||
}
|
||
|
||
fn searchable_dropdown_with(
|
||
ui: &mut Ui,
|
||
id: &str,
|
||
current: &str,
|
||
filter: &mut String,
|
||
options: &[SearchOption<'_>],
|
||
menu: SearchMenu<'_>,
|
||
) -> Option<String> {
|
||
let SearchMenu { custom, pending, icon } = menu;
|
||
crate::prefs_search::note_current(ui, current);
|
||
let mut chosen = None;
|
||
let row = label(ui).to_owned();
|
||
let combo = egui::ComboBox::from_id_salt(id)
|
||
.width(if icon.is_some() { Tokens::get().control_height } else { dimension(ui.available_width()) })
|
||
.height(Tokens::get().space_24 * 14.0)
|
||
.selected_text(if icon.is_some() { "" } else { current })
|
||
.close_behavior(egui::PopupCloseBehavior::CloseOnClickOutside);
|
||
let combo = if let Some(icon) = icon {
|
||
combo.icon(move |ui, rect, _, _| crate::icons::paint_ink(ui.painter(), rect.shrink(Tokens::get().space_2), icon, Tokens::get().form_dim))
|
||
} else {
|
||
combo.icon(dropdown_arrow)
|
||
};
|
||
let popup = super::container::show_combo(ui, ui.make_persistent_id(egui::IdSalt::new(id)), combo, |ui| {
|
||
let search = ui.add(
|
||
text_input(egui::TextEdit::singleline(filter))
|
||
.id_salt(format!("{id}_search"))
|
||
.hint_text(crate::i18n::tr_label("Search"))
|
||
.desired_width(f32::INFINITY),
|
||
);
|
||
// Preferences types into its own search only while no field has the keyboard.
|
||
if search.has_focus() {
|
||
crate::prefs_search::note_key_sink(ui.ctx());
|
||
}
|
||
scenario::publish_handle(&format!("dialog:{row} search"), search.rect.center());
|
||
if let Some(custom) = custom {
|
||
let response = ui.selectable_label(false, custom);
|
||
scenario::publish_handle(&format!("dialog:{row} file"), response.rect.center());
|
||
if response.clicked() {
|
||
chosen = Some(filter.trim().to_owned());
|
||
ui.close();
|
||
}
|
||
return;
|
||
}
|
||
let query = filter.to_lowercase();
|
||
egui::ScrollArea::vertical()
|
||
.id_salt(format!("{id}_list"))
|
||
.max_height(Tokens::get().space_24 * 10.0)
|
||
.min_scrolled_height(Tokens::get().space_24 * 10.0)
|
||
.auto_shrink([false, false])
|
||
.show(ui, |ui| {
|
||
for option in options.iter().filter(|o| o.label.to_lowercase().contains(&query)) {
|
||
let response = ui.selectable_label(current == option.label, option.label);
|
||
if let Some(handle) = option.handle {
|
||
scenario::publish_handle(handle, response.rect.center());
|
||
}
|
||
if response.clicked() {
|
||
chosen = Some(option.value.to_owned());
|
||
ui.close();
|
||
}
|
||
}
|
||
if let Some(pending) = pending {
|
||
ui.label(pending);
|
||
}
|
||
});
|
||
});
|
||
let response = popup.response;
|
||
if popup.inner.is_some() && ui.input_mut(|input| input.consume_key(egui::Modifiers::NONE, egui::Key::Escape)) {
|
||
response.request_focus();
|
||
}
|
||
publish(ui, &response, egui::WidgetType::ComboBox);
|
||
chosen
|
||
}
|
||
|
||
/// Longest search text and custom value a `search_picker` takes.
|
||
const SEARCH_TEXT_CAP: usize = 256;
|
||
/// Characters of a label shown on a `search_picker` row, and of a tip or note shown with it.
|
||
const SEARCH_LABEL_CAP: usize = 64;
|
||
const SEARCH_NOTE_CAP: usize = 1024;
|
||
/// Characters of a `search_picker` note shown under its list; the rest shows on hover.
|
||
const SEARCH_NOTE_SHOWN: usize = 200;
|
||
/// Rows a `search_picker` makes room for when it opens with none.
|
||
const SEARCH_ROWS_AWAITED: usize = 6;
|
||
|
||
/// One row of a `search_picker`. The value, label and tip are searched; `tip` also shows on hover,
|
||
/// and a change of `group` between rows draws a heading.
|
||
pub(crate) struct SearchChoice<'a> {
|
||
pub value: &'a str,
|
||
pub label: &'a str,
|
||
pub tip: &'a str,
|
||
pub group: Option<&'a str>,
|
||
}
|
||
|
||
/// What a `search_picker` shows.
|
||
pub(crate) struct SearchPicker<'a> {
|
||
/// ComboBox id salt; it also keys the search text, so one per picker in the window.
|
||
pub id: &'a str,
|
||
/// Scenario names: the control `{handles}`, its box `{handles}:search`, its custom row
|
||
/// `{handles}:custom` and its rows `{handles}:{value}`.
|
||
pub handles: &'a str,
|
||
/// The text on the closed control, and the value of the row to highlight.
|
||
pub current: &'a str,
|
||
pub current_value: &'a str,
|
||
/// The search box's empty-text hint.
|
||
pub hint: &'a str,
|
||
pub choices: &'a [SearchChoice<'a>],
|
||
/// Offer what was typed as a value of its own when it is not a listed one.
|
||
pub custom: bool,
|
||
/// A dim line under the list: still listing, or why it could not.
|
||
pub note: Option<&'a str>,
|
||
/// With two or more groups, each folds under its header. Before anything is typed, only the
|
||
/// current value's group and this one are open (every group, when neither names one); a group
|
||
/// with a match opens once something is typed; a fold made by hand stays until the popup closes.
|
||
pub open_group: Option<&'a str>,
|
||
pub enabled: bool,
|
||
}
|
||
|
||
/// A `search_picker` choice: a listed value, or one typed into the box.
|
||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||
pub(crate) enum Picked {
|
||
Listed(String),
|
||
Custom(String),
|
||
}
|
||
|
||
/// Dropdown whose popup opens on a focused search box over a list of `choices`, filtered as the
|
||
/// box is typed in, with an optional row taking the typed text as a value of its own. Enter picks
|
||
/// the exact or first match, else the typed text. Only the rows in view are laid out, so a long
|
||
/// list stays cheap. Returns the pick and the control's response.
|
||
/// Tokens: dropdown tokens, field tokens, `space_24`, `font_small`, `text_dim`, `form_card_width`.
|
||
pub(crate) fn search_picker(ui: &mut Ui, p: SearchPicker<'_>) -> egui::InnerResponse<Option<Picked>> {
|
||
crate::prefs_search::note_current(ui, p.current);
|
||
// As in `dropdown_menu_with_close_behavior`: only a search probe skips the real control.
|
||
if crate::prefs_search::querying(ui)
|
||
&& (!ui.is_visible() || (crate::prefs_search::suppress_chrome(ui) && !crate::prefs_search::texts_hit(ui, &[p.current])))
|
||
{
|
||
return egui::InnerResponse::new(None, crate::prefs_search::hidden_response(ui));
|
||
}
|
||
let state = egui::Id::new(p.id);
|
||
let mut picked = None;
|
||
let response = ui
|
||
.add_enabled_ui(p.enabled, |ui| {
|
||
let combo = egui::ComboBox::from_id_salt(p.id)
|
||
.width(dimension(ui.available_width()))
|
||
.height(Tokens::get().space_24 * 20.0)
|
||
.selected_text(p.current)
|
||
.icon(dropdown_arrow)
|
||
.close_behavior(egui::PopupCloseBehavior::CloseOnClickOutside);
|
||
let response = super::container::show_combo(ui, ui.make_persistent_id(egui::IdSalt::new(p.id)), combo, |ui| {
|
||
picked = search_picker_popup(ui, &p, state)
|
||
})
|
||
.response;
|
||
// Closed: the next opening starts with an empty box that has the focus.
|
||
if !egui::ComboBox::is_open(ui.ctx(), response.id) {
|
||
ui.data_mut(|data| {
|
||
data.remove::<String>(state.with("filter"));
|
||
data.remove::<bool>(state.with("focused"));
|
||
data.remove::<f32>(state.with("height"));
|
||
data.remove::<SearchFolds>(state.with("folds"));
|
||
});
|
||
}
|
||
response
|
||
})
|
||
.inner;
|
||
publish(ui, &response, egui::WidgetType::ComboBox);
|
||
scenario::publish_target(p.handles, response.rect);
|
||
egui::InnerResponse::new(picked, response)
|
||
}
|
||
|
||
/// What a `search_picker` shows while it is open; the pick, if one was made this frame.
|
||
fn search_picker_popup(ui: &mut Ui, p: &SearchPicker<'_>, state: egui::Id) -> Option<Picked> {
|
||
let t = Tokens::get();
|
||
let (filter_id, focused_id, folds_id) = (state.with("filter"), state.with("focused"), state.with("folds"));
|
||
// Esc closes this popup only: left in the input, it would also cancel a dialog around it.
|
||
if ui.input_mut(|i| i.consume_key(egui::Modifiers::NONE, egui::Key::Escape)) {
|
||
ui.close();
|
||
}
|
||
ui.style_mut().wrap_mode = Some(egui::TextWrapMode::Truncate);
|
||
// The rows' text starts where the box's and the headings' do.
|
||
ui.spacing_mut().button_padding.x = t.form_inset;
|
||
ui.set_min_width(search_popup_width(ui, p));
|
||
let mut filter: String = ui.data(|data| data.get_temp(filter_id)).unwrap_or_default();
|
||
let search = ui.add(
|
||
text_input(egui::TextEdit::singleline(&mut filter))
|
||
.id(state.with("search"))
|
||
.char_limit(SEARCH_TEXT_CAP)
|
||
.hint_text(p.hint)
|
||
.background_color(t.input_fill())
|
||
.desired_width(f32::INFINITY),
|
||
);
|
||
t.input_bevel(ui, &search);
|
||
scenario::publish_target(&format!("{}:search", p.handles), search.rect);
|
||
// Asked until it has it: over a modal window egui drops the request of the opening's first frame.
|
||
if !ui.data(|data| data.get_temp::<bool>(focused_id)).unwrap_or(false) {
|
||
if search.has_focus() {
|
||
ui.data_mut(|data| data.insert_temp(focused_id, true));
|
||
} else {
|
||
search.request_focus();
|
||
ui.ctx().request_repaint();
|
||
}
|
||
}
|
||
if search.has_focus() {
|
||
crate::prefs_search::note_key_sink(ui.ctx());
|
||
}
|
||
if search.changed() {
|
||
ui.data_mut(|data| data.insert_temp(filter_id, filter.clone()));
|
||
}
|
||
let typed = filter.trim();
|
||
let query: String = typed.chars().flat_map(char::to_lowercase).collect();
|
||
// One buffer for every row: this runs each frame the popup is open, over a list of thousands.
|
||
let mut searched = String::new();
|
||
let mut hit = |choice: &SearchChoice<'_>| {
|
||
searched.clear();
|
||
for text in [choice.value, choice.label, choice.tip] {
|
||
searched.extend(text.chars().take(SEARCH_TEXT_CAP).flat_map(char::to_lowercase));
|
||
searched.push('\n');
|
||
}
|
||
searched.contains(&query)
|
||
};
|
||
let visible: Vec<&SearchChoice<'_>> = p.choices.iter().filter(|choice| query.is_empty() || hit(choice)).collect();
|
||
// Two or more groups fold under their headers: open by default are the current value's group,
|
||
// `open_group`, and every group once something is typed; a fold made by hand stays until the
|
||
// popup closes.
|
||
let grouped = search_groups(p.choices).iter().filter(|(group, _)| group.is_some()).count() >= 2;
|
||
let folds: SearchFolds = ui.data(|data| data.get_temp(folds_id)).unwrap_or_default();
|
||
let current_group = p.choices.iter().find(|c| c.value == p.current_value).and_then(|c| c.group).filter(|g| !g.is_empty());
|
||
let nothing_preferred = p.open_group.is_none() && current_group.is_none();
|
||
let is_open = |group: &str| {
|
||
folds.get(group).copied().unwrap_or(!query.is_empty() || nothing_preferred || Some(group) == p.open_group || Some(group) == current_group)
|
||
};
|
||
let rows = search_rows(&visible, grouped, &is_open);
|
||
let shown: Vec<&SearchChoice<'_>> = rows.iter().filter_map(|row| if let SearchRow::Choice(c) = row { Some(*c) } else { None }).collect();
|
||
let custom = (p.custom && !typed.is_empty() && !p.choices.iter().any(|c| c.value == typed)).then_some(typed);
|
||
let mut picked = None;
|
||
let mut toggled: Option<(String, bool)> = None;
|
||
if search.lost_focus() && ui.input_mut(|i| i.consume_key(egui::Modifiers::NONE, egui::Key::Enter)) {
|
||
let found = visible.iter().find(|c| c.value == typed).or_else(|| shown.first());
|
||
picked = match (typed.is_empty(), found, custom) {
|
||
// Nothing asked for: the choice stands.
|
||
(true, ..) => {
|
||
ui.close();
|
||
None
|
||
}
|
||
(_, Some(choice), _) => Some(Picked::Listed(choice.value.to_owned())),
|
||
(_, None, Some(model)) => Some(Picked::Custom(model.to_owned())),
|
||
(_, None, None) => {
|
||
search.request_focus();
|
||
None
|
||
}
|
||
};
|
||
}
|
||
let width = ui.available_width();
|
||
let note = p.note.map(|note| {
|
||
let shown = compact(note, SEARCH_NOTE_SHOWN);
|
||
ui.painter().layout(shown, egui::FontId::proportional(t.font_small), t.text_dim, width)
|
||
});
|
||
let gap = ui.spacing().item_spacing.y;
|
||
let note_height = note.as_ref().map_or(0.0, |note| note.size().y + gap);
|
||
let row_height = row_height();
|
||
let most = ui.ctx().content_rect().height() - t.space_24 * 4.0;
|
||
// A popup's Ui stays within its size of the last frame, so it can't grow once it is open. All
|
||
// that can change below the box shares a height fixed when it opens, the list taking the rest.
|
||
let height = ui.data_mut(|data| {
|
||
*data.get_temp_mut_or_insert_with(state.with("height"), || {
|
||
let rows = p.choices.len() + search_groups(p.choices).iter().filter(|(group, _)| group.is_some()).count();
|
||
// No rows yet: they may still be on their way, and this can't grow to take them.
|
||
let rows = if rows == 0 { SEARCH_ROWS_AWAITED } else { rows };
|
||
let heading = t.space_16 + gap;
|
||
let custom = if p.custom { heading + row_height + gap } else { 0.0 };
|
||
let list = (rows as f32 * (row_height + gap)).clamp(custom + row_height + gap, t.space_24 * 10.0);
|
||
(heading + list + note_height).min(most).max(heading + custom + row_height + gap)
|
||
})
|
||
});
|
||
ui.allocate_ui(vec2(dimension(width), height), |ui| {
|
||
ui.set_min_height(height);
|
||
if let Some(model) = custom {
|
||
search_heading(ui, crate::i18n::tr("ui.agent_chat_custom_heading"), t.space_16);
|
||
let text = crate::i18n::format("ui.agent_chat_model_custom", &[("model", &compact(model, SEARCH_LABEL_CAP))]);
|
||
let row = search_row(ui, &text, false);
|
||
scenario::publish_target(&format!("{}:custom", p.handles), row.rect);
|
||
if row.clicked() {
|
||
picked = Some(Picked::Custom(model.to_owned()));
|
||
}
|
||
}
|
||
if !visible.is_empty() {
|
||
search_heading(ui, crate::i18n::tr("ui.agent_chat_models_heading"), t.space_16);
|
||
// Rows of one height, group headings too: only those in view are laid out.
|
||
let list = (ui.available_height() - note_height).max(row_height);
|
||
egui::ScrollArea::vertical()
|
||
.id_salt(state.with("list"))
|
||
.max_height(list)
|
||
.min_scrolled_height(list)
|
||
.auto_shrink([false, false])
|
||
.show_rows(ui, row_height, rows.len(), |ui, range| {
|
||
for row in rows.get(range).unwrap_or_default() {
|
||
match row {
|
||
SearchRow::Heading(group) => search_heading(ui, group, row_height),
|
||
SearchRow::Group { name, count, open } => {
|
||
let response = search_group_row(ui, name, *count, *open);
|
||
scenario::publish_target(&format!("{}:group:{}", p.handles, name), response.rect);
|
||
if response.clicked() {
|
||
toggled = Some(((*name).to_owned(), !*open));
|
||
}
|
||
}
|
||
SearchRow::Choice(choice) => {
|
||
let response = search_row(ui, &compact(choice.label, SEARCH_LABEL_CAP), choice.value == p.current_value);
|
||
scenario::publish_target(&format!("{}:{}", p.handles, choice.value), response.rect);
|
||
let response = if choice.tip.is_empty() {
|
||
response
|
||
} else {
|
||
response.backing_on_hover_text(compact(choice.tip, SEARCH_NOTE_CAP))
|
||
};
|
||
if response.clicked() {
|
||
picked = Some(Picked::Listed(choice.value.to_owned()));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
});
|
||
}
|
||
if let Some((group, open)) = toggled {
|
||
let mut folds = folds;
|
||
folds.insert(group, open);
|
||
ui.data_mut(|data| data.insert_temp(folds_id, folds));
|
||
// The click took the focus from the box; typing goes on filtering.
|
||
search.request_focus();
|
||
}
|
||
if let Some(note) = note {
|
||
let response = ui.add(egui::Label::new(note));
|
||
if let Some(whole) = p.note.filter(|whole| whole.chars().count() > SEARCH_NOTE_SHOWN) {
|
||
response.backing_on_hover_text(compact(whole, SEARCH_NOTE_CAP));
|
||
}
|
||
}
|
||
});
|
||
if picked.is_some() {
|
||
ui.close();
|
||
}
|
||
picked
|
||
}
|
||
|
||
enum SearchRow<'a> {
|
||
/// A lone group's dim heading.
|
||
Heading(&'a str),
|
||
/// One of several groups: its header, with how many of its choices are listed, folded or open.
|
||
Group {
|
||
name: &'a str,
|
||
count: usize,
|
||
open: bool,
|
||
},
|
||
Choice(&'a SearchChoice<'a>),
|
||
}
|
||
|
||
/// The folds made by hand in one opening of a `search_picker`: group name to open.
|
||
type SearchFolds = std::collections::HashMap<String, bool>;
|
||
|
||
/// The groups among `choices` in order of first appearance, each with its choices; `None` is the
|
||
/// choices with no group.
|
||
fn search_groups<'a, 'c, I>(choices: I) -> Vec<(Option<&'a str>, Vec<&'c SearchChoice<'a>>)>
|
||
where
|
||
'a: 'c,
|
||
I: IntoIterator<Item = &'c SearchChoice<'a>>,
|
||
{
|
||
let mut groups: Vec<(Option<&'a str>, Vec<&'c SearchChoice<'a>>)> = Vec::new();
|
||
for choice in choices {
|
||
let group = choice.group.filter(|g| !g.is_empty());
|
||
match groups.iter_mut().find(|(name, _)| *name == group) {
|
||
Some((_, members)) => members.push(choice),
|
||
None => groups.push((group, vec![choice])),
|
||
}
|
||
}
|
||
groups
|
||
}
|
||
|
||
/// The list's rows: each group's choices under its header, which folds them when there are several
|
||
/// groups and is a plain heading when there is one; choices with no group as they are.
|
||
fn search_rows<'a>(visible: &[&'a SearchChoice<'a>], grouped: bool, is_open: &dyn Fn(&str) -> bool) -> Vec<SearchRow<'a>> {
|
||
let mut rows = Vec::with_capacity(visible.len());
|
||
for (group, members) in search_groups(visible.iter().copied()) {
|
||
match group {
|
||
Some(name) if grouped => {
|
||
let open = is_open(name);
|
||
rows.push(SearchRow::Group { name, count: members.len(), open });
|
||
if open {
|
||
rows.extend(members.into_iter().map(SearchRow::Choice));
|
||
}
|
||
}
|
||
Some(name) => {
|
||
rows.push(SearchRow::Heading(name));
|
||
rows.extend(members.into_iter().map(SearchRow::Choice));
|
||
}
|
||
None => rows.extend(members.into_iter().map(SearchRow::Choice)),
|
||
}
|
||
}
|
||
rows
|
||
}
|
||
|
||
/// The header of one of several groups in a `search_picker`: a chevron, the name, how many of its
|
||
/// choices are listed, and a rule. A click folds or opens the group.
|
||
fn search_group_row(ui: &mut Ui, name: &str, count: usize, open: bool) -> Response {
|
||
let t = Tokens::get();
|
||
let (rect, response) = ui.allocate_exact_size(vec2(dimension(ui.available_width()), row_height()), egui::Sense::click());
|
||
if !ui.is_rect_visible(rect) {
|
||
return response;
|
||
}
|
||
let painter = ui.painter();
|
||
if response.hovered() {
|
||
painter.rect_filled(rect, t.radius_sm, t.hover);
|
||
}
|
||
let y = rect.center().y;
|
||
super::disclosure(painter, egui::pos2(rect.left() + t.form_inset + t.space_8 * 0.5, y), open, t.text_dim);
|
||
let small = egui::FontId::proportional(t.font_small);
|
||
let title = painter.layout_no_wrap(compact(&name.to_uppercase(), SEARCH_LABEL_CAP), small.clone(), t.text);
|
||
let title_pos = egui::pos2(rect.left() + t.form_inset + t.space_16, y - title.size().y / 2.0);
|
||
let title_width = title.size().x;
|
||
painter.galley(title_pos, title, t.text);
|
||
let number = painter.layout_no_wrap(count.to_string(), small, t.text_dim);
|
||
let pad = t.space_8 * 0.75;
|
||
let badge_height = (number.size().y + pad).min(rect.height());
|
||
let badge = egui::Rect::from_min_size(
|
||
egui::pos2(title_pos.x + title_width + t.space_8, y - badge_height / 2.0),
|
||
vec2(number.size().x + pad * 2.0, badge_height),
|
||
);
|
||
painter.rect_filled(badge, t.radius_sm, t.chip);
|
||
painter.galley(egui::pos2(badge.left() + pad, y - number.size().y / 2.0), number, t.text_dim);
|
||
let (rule_from, rule_to) = (badge.right() + t.space_8, rect.right() - t.form_inset);
|
||
if rule_from < rule_to {
|
||
painter.hline(rule_from..=rule_to, y, egui::Stroke::new(1.0, t.border));
|
||
}
|
||
response.backing_on_hover_text(crate::i18n::format("ui.agent_chat_provider_models", &[("count", &count.to_string())]))
|
||
}
|
||
|
||
/// A `search_picker` row: as `list_picker`, but read from the left, as a list of ids is.
|
||
fn search_row(ui: &mut Ui, text: &str, selected: bool) -> Response {
|
||
ui.add_sized(vec2(dimension(ui.available_width()), row_height()), egui::Button::selectable(selected, (text, egui::Atom::grow())))
|
||
}
|
||
|
||
/// A dim one-line heading in a `search_picker`'s popup.
|
||
fn search_heading(ui: &mut Ui, text: &str, height: f32) {
|
||
let t = Tokens::get();
|
||
let (rect, response) = ui.allocate_exact_size(vec2(dimension(ui.available_width()), height), egui::Sense::hover());
|
||
paint_text(
|
||
ui,
|
||
rect.shrink2(vec2(t.form_inset, 0.0)),
|
||
&compact(text, SEARCH_LABEL_CAP),
|
||
egui::FontId::proportional(t.font_small),
|
||
t.text_dim,
|
||
false,
|
||
);
|
||
if text.chars().count() > SEARCH_LABEL_CAP {
|
||
response.backing_on_hover_text(compact(text, SEARCH_NOTE_CAP));
|
||
}
|
||
}
|
||
|
||
/// A `search_picker` popup's width: the control's, wide enough for the longest label and to search
|
||
/// in, and never wider than the window.
|
||
fn search_popup_width(ui: &Ui, p: &SearchPicker<'_>) -> f32 {
|
||
let t = Tokens::get();
|
||
let longest = p.choices.iter().map(|c| c.label).max_by_key(|label| label.chars().take(SEARCH_LABEL_CAP + 1).count()).unwrap_or("");
|
||
let text = ui.painter().layout_no_wrap(compact(longest, SEARCH_LABEL_CAP), egui::TextStyle::Button.resolve(ui.style()), t.text).size().x;
|
||
let wanted = text + ui.spacing().button_padding.x * 2.0 + ui.spacing().scroll.bar_width + t.space_8;
|
||
let most = (ui.ctx().content_rect().width() - t.space_24 * 2.0).max(0.0);
|
||
dimension(wanted.max(ui.available_width()).max(t.form_card_width).min(most))
|
||
}
|
||
|
||
/// `text` cut to `max_chars`, with an ellipsis if anything was left out.
|
||
fn compact(text: &str, max_chars: usize) -> String {
|
||
let mut chars = text.chars();
|
||
let short: String = chars.by_ref().take(max_chars).collect();
|
||
if chars.next().is_some() { format!("{short}…") } else { short }
|
||
}
|
||
|
||
/// Completion/focus implementation shared by field variants. Tokens: `same as field`.
|
||
fn editor(ui: &mut Ui, value: &mut String, hint: &str, completion: bool) -> (bool, bool, Response) {
|
||
editor_reserving(ui, value, hint, completion, 0.0)
|
||
}
|
||
|
||
/// `editor` whose text stops `reserve` points short of its right edge, for controls drawn there.
|
||
fn editor_reserving(ui: &mut Ui, value: &mut String, hint: &str, completion: bool, reserve: f32) -> (bool, bool, Response) {
|
||
let t = Tokens::get();
|
||
let width = dimension(ui.available_width());
|
||
let font = egui::FontId::monospace(t.font_label);
|
||
let mut edit = text_input(egui::TextEdit::singleline(value)).hint_text(hint).font(font).background_color(t.input_fill()).clip_text(true);
|
||
if reserve > 0.0 {
|
||
let inset = t.form_inset.round() as i8;
|
||
edit = edit.margin(egui::Margin { left: inset, right: inset.saturating_add(reserve.round() as i8), top: 0, bottom: 0 });
|
||
}
|
||
let mut response = ui.add_sized(vec2(width, row_height()), edit);
|
||
if response.has_focus() {
|
||
ui.ctx().data_mut(|data| data.insert_temp(egui::Id::new("sc_focused_editor"), response.id));
|
||
}
|
||
super::text_menu::menu(ui, &mut response, value, super::text_menu::Field::LINE);
|
||
if response.has_focus() {
|
||
crate::prefs_search::note_key_sink(ui.ctx());
|
||
}
|
||
if completion && ui.is_enabled() {
|
||
ui.ctx().data_mut(|data| {
|
||
let id = egui::Id::new("sc_value_fields");
|
||
if data.get_temp::<Vec<(egui::Id, usize)>>(id).is_some() {
|
||
data.get_temp_mut_or_default::<Vec<(egui::Id, usize)>>(id).push((response.id, value.chars().count()));
|
||
}
|
||
});
|
||
}
|
||
crate::theme::TabAccent::number_focus(ui, &response);
|
||
t.input_bevel(ui, &response);
|
||
let label = crate::i18n::tr_label(label(ui));
|
||
response.widget_info(|| {
|
||
let mut info = egui::WidgetInfo::labeled(egui::WidgetType::TextEdit, ui.is_enabled(), label);
|
||
info.current_text_value = Some(value.clone());
|
||
info
|
||
});
|
||
super::layout::publish_geometry(ui, &response);
|
||
// A completion's Enter accepts the suggestion, rather than submitting the dialog.
|
||
let completed = completion && crate::params_dialog::complete(ui, &response, value);
|
||
(!completed && response.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter)), response.changed(), response)
|
||
}
|
||
|
||
/// The one dropdown arrow every kit dropdown draws (the kit chevron, dimmed), instead of egui's triangle.
|
||
fn dropdown_arrow(ui: &Ui, rect: egui::Rect, _visuals: &egui::style::WidgetVisuals, _open: bool) {
|
||
super::dropdown_indicator(ui.painter(), rect, Tokens::get().text_dim);
|
||
}
|
||
|
||
/// Native dropdown with kit arrow and scenario option handles. Tokens: `text_dim; scope control/font tokens`.
|
||
pub(crate) fn dropdown(ui: &mut Ui, id: &str, selected: &mut usize, options: &[&str]) -> Response {
|
||
let text = options.get(*selected).copied().map(crate::i18n::tr_label).unwrap_or("");
|
||
let row = label(ui).to_string();
|
||
dropdown_menu(ui, id, text, |ui| {
|
||
for (index, option) in options.iter().enumerate() {
|
||
let response = ui.selectable_value(selected, index, crate::i18n::tr_label(option));
|
||
scenario::publish_target(&format!("dialog:{row}:{option}"), response.rect);
|
||
}
|
||
})
|
||
}
|
||
|
||
/// The standard dropdown with a leading application icon on the current value and each option.
|
||
/// The text job reserves the icon's space; the native combo and selectable items own interaction.
|
||
pub(crate) fn dropdown_icons(ui: &mut Ui, id: &str, selected: &mut usize, options: &[(&str, &str)]) -> Response {
|
||
let (text, icon) = options.get(*selected).copied().unwrap_or(("", ""));
|
||
let row = label(ui).to_owned();
|
||
dropdown_menu_width(ui, id, text, Some(icon), false, egui::PopupCloseBehavior::CloseOnClick, |ui| {
|
||
for (index, (text, icon)) in options.iter().enumerate() {
|
||
let response = ui.selectable_label(*selected == index, dropdown_icon_text(text));
|
||
paint_dropdown_icon(ui, response.rect, icon);
|
||
scenario::publish_target(&format!("dialog:{row}:{text}"), response.rect);
|
||
if response.clicked() {
|
||
*selected = index;
|
||
}
|
||
}
|
||
})
|
||
}
|
||
|
||
fn dropdown_icon_text(text: &str) -> egui::text::LayoutJob {
|
||
let t = Tokens::get();
|
||
let mut job = egui::text::LayoutJob::default();
|
||
job.append(
|
||
text,
|
||
t.space_16 + t.space_6,
|
||
egui::TextFormat { font_id: egui::FontId::proportional(t.font_label), color: t.form_ink, ..Default::default() },
|
||
);
|
||
job
|
||
}
|
||
|
||
fn paint_dropdown_icon(ui: &Ui, rect: egui::Rect, icon: &str) {
|
||
let t = Tokens::get();
|
||
let rect = egui::Rect::from_center_size(
|
||
egui::pos2(rect.left() + ui.spacing().button_padding.x + t.space_8, rect.center().y),
|
||
vec2(t.space_16, t.space_16),
|
||
);
|
||
crate::icons::paint_ink(ui.painter(), rect, icon, t.form_ink);
|
||
scenario::publish_rect(&format!("dialog:dropdown_icon:{icon}"), rect);
|
||
}
|
||
|
||
/// [`dropdown`] whose options each show a picture beside them while hovered, painted by `preview`
|
||
/// for that option's index, so a choice can be seen before it is picked. Tokens: dropdown tokens,
|
||
/// the tooltip frame.
|
||
pub(crate) fn dropdown_previews(ui: &mut Ui, id: &str, selected: &mut usize, options: &[&str], preview: impl Fn(&mut Ui, usize)) -> Response {
|
||
let text = options.get(*selected).copied().map(crate::i18n::tr_label).unwrap_or("");
|
||
let row = label(ui).to_string();
|
||
dropdown_menu(ui, id, text, |ui| {
|
||
for (index, option) in options.iter().enumerate() {
|
||
let response = ui.selectable_value(selected, index, crate::i18n::tr_label(option));
|
||
scenario::publish_target(&format!("dialog:{row}:{option}"), response.rect);
|
||
Container::tooltip_ui(&response, |ui| {
|
||
preview(ui, index);
|
||
scenario::publish_rect(&format!("dialog:preview:{row}:{option}"), ui.min_rect());
|
||
});
|
||
}
|
||
})
|
||
}
|
||
|
||
/// [`dropdown`] that also says whether an option was clicked, the one already shown included (a
|
||
/// pick of the shown option changes nothing, yet it is a choice).
|
||
pub(crate) fn dropdown_picked(ui: &mut Ui, id: &str, selected: &mut usize, options: &[&str]) -> bool {
|
||
let text = options.get(*selected).copied().map(crate::i18n::tr_label).unwrap_or("");
|
||
let row = label(ui).to_string();
|
||
let mut picked = false;
|
||
dropdown_menu(ui, id, text, |ui| {
|
||
for (index, option) in options.iter().enumerate() {
|
||
let response = ui.selectable_value(selected, index, crate::i18n::tr_label(option));
|
||
picked |= response.clicked();
|
||
scenario::publish_handle(&format!("dialog:{row}:{option}"), response.rect.center());
|
||
}
|
||
});
|
||
picked
|
||
}
|
||
|
||
/// Dropdown with caller-supplied kit choices/actions, including disabled entries and stable
|
||
/// application handles. Tokens: dropdown tokens. Use `dropdown` for a simple indexed list.
|
||
pub(crate) fn dropdown_menu(ui: &mut Ui, id: impl egui::AsIdSalt, current: &str, add: impl FnOnce(&mut Ui)) -> Response {
|
||
dropdown_menu_with_close_behavior(ui, id, current, egui::PopupCloseBehavior::CloseOnClick, add)
|
||
}
|
||
|
||
/// Dropdown with explicit dismissal behavior. For editable content use `CloseOnClickOutside`
|
||
/// and close the popup when a choice is accepted.
|
||
pub(crate) fn dropdown_menu_with_close_behavior(
|
||
ui: &mut Ui,
|
||
id: impl egui::AsIdSalt,
|
||
current: &str,
|
||
close_behavior: egui::PopupCloseBehavior,
|
||
add: impl FnOnce(&mut Ui),
|
||
) -> Response {
|
||
dropdown_menu_width(ui, id, current, None, false, close_behavior, add)
|
||
}
|
||
|
||
/// Intrinsic-width variant for horizontal toolbars and bottom strips.
|
||
pub(crate) fn compact_dropdown_menu(ui: &mut Ui, id: impl egui::AsIdSalt, current: &str, add: impl FnOnce(&mut Ui)) -> Response {
|
||
dropdown_menu_width(ui, id, current, None, true, egui::PopupCloseBehavior::CloseOnClick, add)
|
||
}
|
||
|
||
fn dropdown_menu_width(
|
||
ui: &mut Ui,
|
||
id: impl egui::AsIdSalt,
|
||
current: &str,
|
||
leading_icon: Option<&str>,
|
||
compact: bool,
|
||
close_behavior: egui::PopupCloseBehavior,
|
||
add: impl FnOnce(&mut Ui),
|
||
) -> Response {
|
||
crate::prefs_search::note_current(ui, current);
|
||
// Only a search probe may skip the real control. A dialog's first frame is not visible yet,
|
||
// and a stand-in there makes the next frame too short to show OK.
|
||
if crate::prefs_search::querying(ui)
|
||
&& (!ui.is_visible() || (crate::prefs_search::suppress_chrome(ui) && !crate::prefs_search::texts_hit(ui, &[current])))
|
||
{
|
||
return crate::prefs_search::hidden_response(ui);
|
||
}
|
||
let t = Tokens::get();
|
||
let width = if compact {
|
||
ui.painter().layout_no_wrap(current.to_owned(), egui::FontId::proportional(t.font_label), t.form_ink).size().x + t.space_24 + t.space_8
|
||
} else {
|
||
dimension(ui.available_width())
|
||
};
|
||
let selected_text = if leading_icon.is_some() { egui::WidgetText::from(dropdown_icon_text(current)) } else { current.into() };
|
||
let widget = ui.make_persistent_id(egui::IdSalt::new(&id));
|
||
let combo = egui::ComboBox::from_id_salt(id)
|
||
.width(width)
|
||
.height(Tokens::get().space_24 * 14.0)
|
||
.selected_text(selected_text)
|
||
.icon(dropdown_arrow)
|
||
.close_behavior(close_behavior);
|
||
let popup = super::container::show_combo(ui, widget, combo, add);
|
||
let response = popup.response;
|
||
// The native popup closes on Escape; keep the same key from reaching the enclosing window.
|
||
// Only this dropdown's shown popup owns the key, and its trigger regains keyboard focus.
|
||
if popup.inner.is_some() && ui.input_mut(|input| input.consume_key(egui::Modifiers::NONE, egui::Key::Escape)) {
|
||
response.request_focus();
|
||
}
|
||
if let Some(icon) = leading_icon {
|
||
paint_dropdown_icon(ui, response.rect, icon);
|
||
}
|
||
publish(ui, &response, egui::WidgetType::ComboBox);
|
||
response
|
||
}
|
||
|
||
/// Selection target state; filled targets retain their reserved trailing space.
|
||
pub(crate) struct Selection {
|
||
pub active: bool,
|
||
pub filled: bool,
|
||
}
|
||
|
||
/// Three looks: the active input in accent, a filled one in a quiet neutral tint, an empty one plain.
|
||
pub(crate) fn selection_field(ui: &mut Ui, text: &str, options: Selection) -> Response {
|
||
let Selection { active, filled } = options;
|
||
let t = Tokens::get();
|
||
let (rect, response) = ui.allocate_exact_size(vec2(dimension(ui.available_width()), row_height()), egui::Sense::CLICK);
|
||
// A separate action fill lets two-colour palettes reserve the focus accent for inverted ink.
|
||
let inverted = t.form_primary_fill != t.form_primary;
|
||
if active && !filled && !inverted {
|
||
ui.painter().rect_filled(rect, t.control_radius, t.selected_bg);
|
||
}
|
||
let (fill, border) = match (active, filled) {
|
||
(true, _) if inverted => (t.selected_bg, t.form_primary),
|
||
(false, _) if inverted => (t.control_fill, t.control_border),
|
||
(true, true) => (t.selected_bg, t.form_primary),
|
||
(true, false) => (t.control_fill, t.form_primary),
|
||
(false, true) => (t.control_fill.lerp_to_gamma(t.form_ink, 0.06), t.control_border.lerp_to_gamma(t.form_ink, 0.35)),
|
||
(false, false) => (t.control_fill, t.control_border),
|
||
};
|
||
ui.painter().rect(
|
||
if active && !filled && !inverted { rect.shrink(t.space_2) } else { rect },
|
||
t.control_radius,
|
||
fill,
|
||
match (active, filled) {
|
||
(true, _) => egui::Stroke::new(1.0, border),
|
||
// A theme's control border can fix its own colour; a filled field keeps its tint.
|
||
(false, true) => egui::Stroke::new(t.control_border_stroke(border).width, border),
|
||
(false, false) => t.control_border_stroke(border),
|
||
},
|
||
egui::StrokeKind::Inside,
|
||
);
|
||
let end = if filled { t.space_24 } else { t.space_8 };
|
||
let text_rect = egui::Rect::from_min_max(
|
||
rect.min + vec2(t.form_inset.min(rect.width()), 0.0),
|
||
egui::pos2((rect.right() - end).max(rect.left() + t.form_inset.min(rect.width())), rect.bottom()),
|
||
);
|
||
paint_text(
|
||
ui,
|
||
text_rect,
|
||
text,
|
||
crate::fonts::medium(t.font_label),
|
||
match (active, filled) {
|
||
(true, _) if inverted => t.selected_ink,
|
||
(true, true) => t.selected_ink,
|
||
(false, true) => t.form_ink,
|
||
_ => t.form_dim,
|
||
},
|
||
false,
|
||
);
|
||
publish(ui, &response, egui::WidgetType::Button);
|
||
scenario::publish_rect(&format!("dialog:field:{}", label(ui)), rect);
|
||
scenario::publish_count(&format!("dialog:selection:{}:filled", label(ui)), f64::from(filled));
|
||
scenario::publish_count(&format!("dialog:selection:{}:active", label(ui)), f64::from(active));
|
||
response
|
||
}
|
||
|
||
/// Paired values with compact captions and optional independent scenario/accessibility names.
|
||
pub(crate) fn value_pair(ui: &mut Ui, label: &str, values: [&mut String; 2], axes: [&str; 2], names: Option<[&str; 2]>) -> bool {
|
||
let names = names.unwrap_or(axes);
|
||
let t = Tokens::get();
|
||
super::row(ui, label, |ui| {
|
||
let width = ((dimension(ui.available_width()) - t.space_8) / 2.0).max(0.0);
|
||
let mut enter = false;
|
||
ui.spacing_mut().item_spacing.x = t.space_8;
|
||
for ((axis, value), name) in axes.into_iter().zip(values).zip(names) {
|
||
ui.allocate_ui_with_layout(vec2(width, row_height()), egui::Layout::left_to_right(egui::Align::Center), |ui| {
|
||
ui.set_clip_rect(ui.clip_rect().intersect(ui.max_rect()));
|
||
ui.label(RichText::new(axis).size(t.font_label).color(t.dialog_label));
|
||
enter |= super::layout::named_control(ui, name, |ui| field(ui, value));
|
||
});
|
||
}
|
||
enter
|
||
})
|
||
}
|
||
|
||
/// Paired bounded numeric fields in the shared value-pair row geometry.
|
||
pub(crate) fn number_pair<T: egui::emath::Numeric>(
|
||
ui: &mut Ui,
|
||
label: &str,
|
||
values: [&mut T; 2],
|
||
range: std::ops::RangeInclusive<T>,
|
||
speed: f64,
|
||
suffix: &str,
|
||
) -> [Response; 2] {
|
||
let t = Tokens::get();
|
||
super::row(ui, label, |ui| {
|
||
let width = ((dimension(ui.available_width()) - t.space_8) / 2.0).max(0.0);
|
||
ui.spacing_mut().item_spacing.x = t.space_8;
|
||
values.map(|value| {
|
||
ui.allocate_ui_with_layout(vec2(width, row_height()), egui::Layout::left_to_right(egui::Align::Center), |ui| {
|
||
ui.set_clip_rect(ui.clip_rect().intersect(ui.max_rect()));
|
||
number_field(ui, value, range.clone(), speed, suffix)
|
||
})
|
||
.inner
|
||
})
|
||
})
|
||
}
|
||
|
||
/// Variable-radius location editor. Tokens: scope's control and typography tokens.
|
||
/// Retains the established 0.01 step, fractional range and locale parser.
|
||
/// Locale-aware variable-radius position editor. Tokens: `scope control/font tokens`.
|
||
pub(crate) fn fraction_field(ui: &mut Ui, value: &mut f64) -> Response {
|
||
let response = ui.add(egui::DragValue::new(value).speed(0.01).range(0.01..=0.99).fixed_decimals(2).custom_parser(crate::prefs::parse_number));
|
||
scenario::publish_target(&format!("dialog:fraction:{}", label(ui)), response.rect);
|
||
response
|
||
}
|
||
|
||
#[cfg(test)]
|
||
#[path = "fields_tests.rs"]
|
||
mod tests;
|
||
|
||
/// Stable-ID inline editor for tables. Completion is owned by the caller so Enter can commit
|
||
/// a cell without submitting its panel. Tokens: control_height/fill, form_inset, font_label, text/error.
|
||
pub fn cell_editor(ui: &mut Ui, id: egui::Id, value: &mut String, hint: &str, invalid: bool) -> Response {
|
||
bounded_cell_editor(ui, id, value, hint, invalid, usize::MAX)
|
||
}
|
||
|
||
/// Stable-ID cell/name editor with a caller-supplied character cap. Tokens: cell_editor tokens.
|
||
pub(crate) fn bounded_cell_editor(ui: &mut Ui, id: egui::Id, value: &mut String, hint: &str, invalid: bool, limit: usize) -> Response {
|
||
cell_editor_frame(ui, id, value, hint, invalid, limit, true)
|
||
}
|
||
|
||
fn cell_editor_frame(ui: &mut Ui, id: egui::Id, value: &mut String, hint: &str, invalid: bool, limit: usize, frame: bool) -> Response {
|
||
let t = Tokens::get();
|
||
let editor = text_input(egui::TextEdit::singleline(value))
|
||
.char_limit(limit)
|
||
.id(id)
|
||
.hint_text(crate::i18n::tr_label(hint))
|
||
.font(if frame { egui::FontId::monospace(t.font_label) } else { egui::FontId::proportional(t.font_label) })
|
||
.background_color(if invalid { t.form_error_fill } else { t.input_fill() })
|
||
.text_color(if invalid { t.form_error } else { t.form_ink })
|
||
.clip_text(true);
|
||
let editor = if invalid {
|
||
editor.frame(
|
||
egui::Frame::NONE
|
||
.inner_margin(egui::Margin::symmetric(t.form_inset as i8, 0))
|
||
.fill(t.form_error_fill)
|
||
.stroke(egui::Stroke::new(1.0, t.form_error))
|
||
.corner_radius(t.control_radius),
|
||
)
|
||
} else if frame {
|
||
editor
|
||
} else {
|
||
editor.frame(egui::Frame::NONE.inner_margin(egui::Margin::symmetric(t.space_8 as i8, 0)))
|
||
};
|
||
let mut response = ui.add_sized(vec2(dimension(ui.available_width()), row_height()), editor);
|
||
super::text_menu::menu(ui, &mut response, value, super::text_menu::Field::LINE.limited(limit));
|
||
if frame {
|
||
publish(ui, &response, egui::WidgetType::TextEdit);
|
||
} else {
|
||
super::layout::publish_geometry(ui, &response);
|
||
}
|
||
response.widget_info(|| {
|
||
let mut info = egui::WidgetInfo::labeled(egui::WidgetType::TextEdit, ui.is_enabled(), crate::i18n::tr_label(label(ui)));
|
||
info.current_text_value = Some(value.clone());
|
||
info
|
||
});
|
||
crate::theme::TabAccent::number_focus(ui, &response);
|
||
t.input_bevel(ui, &response);
|
||
response
|
||
}
|
||
|
||
/// Table cell editor that opens wide while it has the focus and its text no longer fits
|
||
/// (#9358): over the cells to its right up to `right`, wrapping onto as many lines as the text
|
||
/// needs, with `note` (the live value, or an error when its flag is set) under it. Otherwise,
|
||
/// and when there is no room to its right, it is [`cell_editor`]. Enter does not break the
|
||
/// line: the caller commits on it as for the cell. Tokens: cell_editor tokens, popup frame.
|
||
pub fn wide_cell_editor(ui: &mut Ui, id: egui::Id, value: &mut String, hint: &str, invalid: bool, right: f32, note: (&str, bool)) -> Response {
|
||
let t = Tokens::get();
|
||
let cell = egui::Rect::from_min_size(ui.cursor().min, vec2(dimension(ui.available_width()), row_height()));
|
||
let focused = ui.memory(|m| m.has_focus(id) || m.had_focus_last_frame(id));
|
||
let font = egui::FontId::monospace(t.font_label);
|
||
let text_width = ui.fonts_mut(|f| f.layout_no_wrap(value.clone(), font.clone(), t.form_ink)).size().x;
|
||
let fits = text_width + 2.0 * t.form_inset <= cell.width();
|
||
if !focused || fits || right <= cell.right() || !ui.is_rect_visible(cell) {
|
||
return cell_editor(ui, id, value, hint, invalid);
|
||
}
|
||
// The cell keeps its place in the row; the editor itself floats over it.
|
||
let (rect, _) = ui.allocate_exact_size(cell.size(), egui::Sense::hover());
|
||
ui.painter().rect_filled(rect, t.control_radius, if invalid { t.form_error_fill } else { t.input_fill() });
|
||
let width = right - rect.left();
|
||
let (ctx, enabled) = (ui.ctx().clone(), ui.is_enabled());
|
||
// The border sits outside the cell, so the text stays where it was.
|
||
let border = t.primary_border(t.dialog_border);
|
||
let area = Container::new(&ctx, Surface::Popup)
|
||
.area(id.with("wide"))
|
||
.fixed_pos(rect.min - vec2(border.width, border.width))
|
||
.constrain(true)
|
||
.order(egui::Order::Foreground);
|
||
let shown = area.show(&ctx, |ui| {
|
||
Container::popup_frame(ui.style())
|
||
.fill(t.control_fill)
|
||
.stroke(border)
|
||
.corner_radius(t.control_radius)
|
||
.inner_margin(0.0)
|
||
.show(ui, |ui| {
|
||
ui.set_width(width);
|
||
let editor = text_input(egui::TextEdit::multiline(value))
|
||
.id(id)
|
||
.return_key(None)
|
||
.desired_rows(1)
|
||
.desired_width(width)
|
||
.hint_text(crate::i18n::tr_label(hint))
|
||
.font(font)
|
||
.background_color(if invalid { t.form_error_fill } else { t.input_fill() })
|
||
.text_color(if invalid { t.form_error } else { t.form_ink });
|
||
let mut response = ui.add(editor);
|
||
// The area's first frame is a sizing pass that disables its widgets, and egui
|
||
// takes the focus from a disabled one: hand it straight back.
|
||
if ui.is_sizing_pass() {
|
||
response.request_focus();
|
||
}
|
||
// It wraps but stays one line: Enter ends the edit as in a single-line field.
|
||
// Raw events, as the table reads them: an accepted completion has already taken its Enter.
|
||
let enter = ui.input(|i| {
|
||
i.raw.events.iter().any(|e| {
|
||
matches!(e, egui::Event::Key { key: egui::Key::Enter, pressed: true, repeat: false, modifiers, .. } if *modifiers == egui::Modifiers::NONE)
|
||
})
|
||
});
|
||
if response.has_focus() && enter {
|
||
response.surrender_focus();
|
||
}
|
||
super::text_menu::menu(ui, &mut response, value, super::text_menu::Field::LINE);
|
||
publish(ui, &response, egui::WidgetType::TextEdit);
|
||
crate::theme::TabAccent::number_focus(ui, &response);
|
||
t.input_bevel(ui, &response);
|
||
let (text, error) = note;
|
||
if !text.is_empty() {
|
||
ui.add_space(t.space_2);
|
||
ui.horizontal(|ui| {
|
||
ui.add_space(t.form_inset);
|
||
ui.add(egui::Label::new(RichText::new(text).size(t.font_small).color(if error { t.form_error } else { t.form_dim })).wrap());
|
||
});
|
||
ui.add_space(t.space_2);
|
||
}
|
||
response
|
||
})
|
||
.inner
|
||
});
|
||
let response = shown.inner;
|
||
response.widget_info(|| {
|
||
let mut info = egui::WidgetInfo::labeled(egui::WidgetType::TextEdit, enabled, crate::i18n::tr_label(hint));
|
||
info.current_text_value = Some(value.clone());
|
||
info
|
||
});
|
||
response
|
||
}
|
||
|
||
/// Search input with native accessibility and a stable caller ID. Tokens: cell_editor tokens.
|
||
pub(crate) fn search_field(ui: &mut Ui, id: egui::Id, value: &mut String, hint: &str) -> Response {
|
||
let t = Tokens::get();
|
||
let catalog = super::layout::in_catalog(ui);
|
||
let height = if catalog { t.space_16 + t.space_2 } else { t.control_height };
|
||
let limit = if catalog { 128 } else { usize::MAX };
|
||
let editor = text_input(egui::TextEdit::singleline(value))
|
||
.id(id)
|
||
.char_limit(limit)
|
||
.hint_text(hint)
|
||
.min_size(vec2(0.0, height))
|
||
.margin(egui::Margin { left: t.space_24 as i8, right: t.space_8 as i8, top: 0, bottom: 0 })
|
||
.font(egui::FontId::proportional(t.font_small))
|
||
.background_color(t.input_fill())
|
||
.clip_text(true)
|
||
.text_color(t.form_ink);
|
||
let mut response = ui.add_sized(vec2(dimension(ui.available_width()), height), editor);
|
||
super::text_menu::menu(ui, &mut response, value, super::text_menu::Field::LINE.limited(limit));
|
||
let icon = egui::Rect::from_center_size(egui::pos2(response.rect.left() + t.space_12, response.rect.center().y), vec2(t.space_12, t.space_12));
|
||
crate::icons::paint_ink(ui.painter(), icon, "zoom", t.form_dim);
|
||
super::layout::publish_geometry(ui, &response);
|
||
response.widget_info(|| {
|
||
let mut info = egui::WidgetInfo::labeled(egui::WidgetType::TextEdit, ui.is_enabled(), hint);
|
||
info.current_text_value = Some(value.clone());
|
||
info
|
||
});
|
||
if response.has_focus() {
|
||
crate::prefs_search::note_key_sink(ui.ctx());
|
||
}
|
||
crate::theme::TabAccent::number_focus(ui, &response);
|
||
t.input_bevel(ui, &response);
|
||
response
|
||
}
|
||
|
||
/// Compact icon action opening the shared searchable menu.
|
||
pub(crate) fn searchable_icon_dropdown(
|
||
ui: &mut Ui,
|
||
icon: &'static str,
|
||
label: &str,
|
||
filter: &mut String,
|
||
options: &[SearchOption<'_>],
|
||
) -> Option<String> {
|
||
searchable_dropdown_with(ui, "icon_search_menu", label, filter, options, SearchMenu { custom: None, pending: None, icon: Some(icon) })
|
||
}
|
||
|
||
/// The filter at the top of a long menu: a search glyph, a frameless editor and a rule under
|
||
/// them, so it reads as the menu's search box and not as one more entry. Tokens: `space_8/16,
|
||
/// font_label, form_dim, form_ink, dialog_rule`.
|
||
pub(crate) fn menu_filter(ui: &mut Ui, id: egui::Id, value: &mut String, hint: &str) -> Response {
|
||
let t = Tokens::get();
|
||
let (rect, _) = ui.allocate_exact_size(vec2(dimension(ui.available_width()), row_height()), egui::Sense::hover());
|
||
let glyph = egui::Rect::from_center_size(egui::pos2(rect.left() + t.space_8 + t.space_16 / 2.0, rect.center().y), vec2(t.space_16, t.space_16));
|
||
crate::icons::paint_ink(ui.painter(), glyph, "zoom", t.form_dim);
|
||
let field = egui::Rect::from_min_max(egui::pos2((glyph.right() + t.space_8).min(rect.right()), rect.top()), rect.max);
|
||
let hint_text = crate::i18n::tr_label(hint);
|
||
let response = ui
|
||
.scope_builder(egui::UiBuilder::new().max_rect(field).layout(egui::Layout::left_to_right(egui::Align::Center)), |ui| {
|
||
ui.set_clip_rect(ui.clip_rect().intersect(field));
|
||
ui.add_sized(
|
||
field.size(),
|
||
text_input(egui::TextEdit::singleline(value))
|
||
.id(id)
|
||
.char_limit(256)
|
||
.hint_text(hint_text)
|
||
.font(egui::FontId::proportional(t.font_label))
|
||
.text_color(t.form_ink)
|
||
.frame(egui::Frame::NONE)
|
||
.clip_text(true),
|
||
)
|
||
})
|
||
.inner;
|
||
response.widget_info(|| {
|
||
let mut info = egui::WidgetInfo::labeled(egui::WidgetType::TextEdit, ui.is_enabled(), hint_text);
|
||
info.current_text_value = Some(value.clone());
|
||
info
|
||
});
|
||
super::layout::publish_geometry(ui, &response);
|
||
if ui.rect_contains_pointer(rect) {
|
||
ui.ctx().set_cursor_icon(egui::CursorIcon::Text);
|
||
}
|
||
super::Menu::separator(ui);
|
||
response
|
||
}
|
||
|
||
/// Behaviour of the one kit slider. Appearance is always owned by `slider`.
|
||
/// Values/ranges stay in caller units; formatting never rounds saved values during drawing.
|
||
pub(crate) struct Slider {
|
||
pub step: Option<f64>,
|
||
pub format: fn(f64) -> String,
|
||
pub show_value: bool,
|
||
pub integer: bool,
|
||
pub workspace_accent: bool,
|
||
/// Blur's off endpoint uses a muted hollow thumb; positive values use solid accent.
|
||
pub off_endpoint: bool,
|
||
}
|
||
|
||
/// Bounded read-only code box for diagnostic payloads. Native selection and copying
|
||
/// remain available; the caller's source cannot be edited. Uses shared form styling.
|
||
pub(crate) fn read_only_text(ui: &mut Ui, text: &str) -> Response {
|
||
let mut source = text;
|
||
egui::ScrollArea::vertical()
|
||
.max_height(160.0)
|
||
.show(ui, |ui| {
|
||
let mut response = ui.add(egui::TextEdit::multiline(&mut source).code_editor().desired_width(ui.available_width()).desired_rows(8));
|
||
super::text_menu::menu(ui, &mut response, &mut source, super::text_menu::Field::LINES);
|
||
response
|
||
})
|
||
.inner
|
||
}
|
||
|
||
impl Default for Slider {
|
||
fn default() -> Self {
|
||
Self { step: None, format: |v| format!("{v:.2}"), show_value: true, integer: false, workspace_accent: false, off_endpoint: false }
|
||
}
|
||
}
|
||
|
||
/// The only slider element, including stepped preferences and editor-free timeline controls.
|
||
/// Native input, keyboard routing, enabled state and accessibility; one token-painted track/thumb.
|
||
/// Tokens: control_height, space_24/8/4/2, dialog_rule, control_fill, form_primary.
|
||
pub(crate) fn slider<T: egui::emath::Numeric>(ui: &mut Ui, value: &mut T, range: std::ops::RangeInclusive<T>, options: Slider) -> Response {
|
||
if crate::prefs_search::suppress_chrome(ui) {
|
||
return crate::prefs_search::hidden_response(ui);
|
||
}
|
||
// Own form styling even in callers such as the viewport menu which have no kit scope.
|
||
super::scope(ui, |ui| {
|
||
let t = Tokens::get();
|
||
ui.style_mut().drag_value_text_style = egui::TextStyle::Monospace;
|
||
let primary = if options.workspace_accent { crate::theme::TabAccent::current(ui.ctx()).ink } else { t.form_primary };
|
||
let limits = (range.start().to_f64(), range.end().to_f64());
|
||
let reserved = if options.show_value {
|
||
// Reserve the actual formatted editor, including suffixes and localized Instant.
|
||
// Endpoints keep its width stable as a preference is dragged through its range.
|
||
let font = egui::TextStyle::Monospace.resolve(ui.style());
|
||
let text_width = [limits.0, limits.1, value.to_f64()]
|
||
.into_iter()
|
||
.map(|v| ui.painter().layout_no_wrap((options.format)(v), font.clone(), t.form_ink).size().x.ceil())
|
||
.fold(0.0, f32::max);
|
||
let editor_width = (text_width + ui.spacing().button_padding.x * 2.0).max(ui.spacing().interact_size.x);
|
||
(editor_width + ui.spacing().item_spacing.x).max(t.space_24 * 2.0 + t.space_4)
|
||
} else {
|
||
t.space_4
|
||
};
|
||
ui.spacing_mut().slider_width = dimension(ui.available_width() - reserved);
|
||
let mut widget =
|
||
egui::Slider::new(value, range).show_value(options.show_value).handle_shape(egui::style::HandleShape::Circle).trailing_fill(false);
|
||
if options.off_endpoint {
|
||
// Blur's step is an editing affordance, not a persisted/API quantisation rule.
|
||
widget = widget.clamping(egui::SliderClamping::Edits);
|
||
}
|
||
if options.show_value {
|
||
widget = widget.custom_formatter(move |v, _| (options.format)(v));
|
||
}
|
||
if let Some(step) = options.step {
|
||
widget = widget.step_by(step);
|
||
}
|
||
if options.integer {
|
||
widget = widget.integer();
|
||
}
|
||
let layer = ui.layer_id();
|
||
let paint_start = ui.ctx().graphics(|graphics| graphics.get(layer).map_or(egui::layers::ShapeIdx(0), |list| list.next_idx()));
|
||
let response = ui.add(widget);
|
||
let slider = egui::Rect::from_min_size(response.rect.min, vec2(ui.spacing().slider_width, response.rect.height()));
|
||
// egui 0.36.2 paints the rail, then the circular handle, then the value editor.
|
||
// Suppress only a positively identified pair added by this widget. A backing
|
||
// rectangle would flatten translucent/blurred parents. Unexpected painting
|
||
// (including an invisible or clipped widget) keeps the native shapes intact.
|
||
ui.ctx().graphics_mut(|graphics| {
|
||
let Some(list) = graphics.get_mut(layer) else { return };
|
||
let paint_end = list.next_idx();
|
||
if paint_end.0.saturating_sub(paint_start.0) < 2 {
|
||
return;
|
||
}
|
||
let handle_idx = egui::layers::ShapeIdx(paint_start.0 + 1);
|
||
let rail_height = ui.spacing().slider_rail_height.max(0.0);
|
||
let native_radius = slider.height() / 2.5;
|
||
let native_range = slider.x_range().shrink(native_radius);
|
||
let mut rail_matches = false;
|
||
let mut handle_matches = false;
|
||
// Indexed reads via mutate_shape are bounded and allocate nothing; do not
|
||
// scan the layer's earlier parent/sibling paints looking for a match.
|
||
list.mutate_shape(paint_start, |entry| {
|
||
if let egui::Shape::Rect(rail) = &entry.shape {
|
||
let expected = egui::Rect::from_center_size(slider.center(), vec2(slider.width(), rail_height));
|
||
rail_matches = entry.clip_rect == ui.clip_rect()
|
||
&& (rail.rect.min - expected.min).length_sq() < 0.0001
|
||
&& (rail.rect.max - expected.max).length_sq() < 0.0001
|
||
&& rail.stroke == egui::Stroke::NONE;
|
||
}
|
||
});
|
||
list.mutate_shape(handle_idx, |entry| {
|
||
if let egui::Shape::Circle(handle) = &entry.shape {
|
||
handle_matches = entry.clip_rect == ui.clip_rect()
|
||
&& (handle.center.y - slider.center().y).abs() < 0.01
|
||
// egui's handle range reverses when the control is narrower
|
||
// than its diameter; either endpoint still belongs to it.
|
||
&& handle.center.x >= native_range.min.min(native_range.max) - 0.01
|
||
&& handle.center.x <= native_range.min.max(native_range.max) + 0.01
|
||
&& (handle.radius - native_radius).abs() < 0.01;
|
||
}
|
||
});
|
||
if rail_matches && handle_matches {
|
||
list.mutate_shape(paint_start, |entry| entry.shape = egui::Shape::Noop);
|
||
list.mutate_shape(handle_idx, |entry| entry.shape = egui::Shape::Noop);
|
||
}
|
||
});
|
||
if ui.ctx().memory(|memory| memory.focused()).is_some_and(|id| {
|
||
ui.ctx().read_response(id).is_some_and(|focused| response.rect.contains(focused.rect.center()))
|
||
|| egui::TextEdit::load_state(ui.ctx(), id).is_some()
|
||
}) {
|
||
crate::prefs_search::note_key_sink(ui.ctx());
|
||
}
|
||
// Match egui's native input range (handle_radius = thickness / 2.5), so the
|
||
// painted thumb stays under the pointer even at the two ends of the range.
|
||
let input_radius = ui.text_style_height(&egui::TextStyle::Body).max(ui.spacing().interact_size.y) / 2.5;
|
||
let track = egui::Rect::from_center_size(slider.center(), vec2((slider.width() - input_radius * 2.0).max(0.0), t.space_4));
|
||
let fraction = if limits.1 != limits.0 { ((value.to_f64() - limits.0) / (limits.1 - limits.0)).clamp(0.0, 1.0) as f32 } else { 0.0 };
|
||
let center = egui::pos2(egui::lerp(track.x_range(), fraction), track.center().y);
|
||
ui.painter().rect_filled(track, t.control_radius, t.dialog_rule);
|
||
ui.painter().rect_filled(egui::Rect::from_min_max(track.min, egui::pos2(center.x, track.bottom())), t.control_radius, primary);
|
||
let off = options.off_endpoint && value.to_f64() == 0.0;
|
||
let fill = if off {
|
||
egui::Color32::TRANSPARENT
|
||
} else if options.off_endpoint {
|
||
primary
|
||
} else {
|
||
t.control_fill
|
||
};
|
||
ui.painter().circle(center, t.space_8, fill, egui::Stroke::new(t.space_2, if off { t.form_dim } else { primary }));
|
||
publish(ui, &response, egui::WidgetType::Slider);
|
||
response.widget_info(|| egui::WidgetInfo::slider(ui.is_enabled(), value.to_f64(), crate::i18n::tr_label(label(ui))));
|
||
scenario::publish_rect(&format!("dialog:slider_track:{}", label(ui)), slider);
|
||
scenario::publish_target(&format!("dialog:slider:{}", label(ui)), response.rect);
|
||
response
|
||
})
|
||
}
|
||
|
||
/// Shared slider with a compact mixed-aware value editor at the right.
|
||
/// The caller owns commit timing, just as for `mixed_scalar_field`.
|
||
pub(crate) fn mixed_slider(ui: &mut Ui, value: &mut f64, range: std::ops::RangeInclusive<f64>, mixed: Option<&str>) -> Response {
|
||
let t = Tokens::get();
|
||
ui.horizontal(|ui| {
|
||
let width = if mixed.is_some() { t.space_24 * 2.0 } else { t.space_24 + t.space_12 };
|
||
let track = ui
|
||
.allocate_ui(vec2((ui.available_width() - width - t.space_8).max(0.0), row_height()), |ui| {
|
||
slider(ui, value, range.clone(), Slider { show_value: false, workspace_accent: true, ..Default::default() })
|
||
})
|
||
.inner;
|
||
let field = ui
|
||
.allocate_ui(vec2(width, row_height()), |ui| {
|
||
ui.visuals_mut().widgets.inactive.bg_fill = egui::Color32::TRANSPARENT;
|
||
ui.visuals_mut().widgets.inactive.bg_stroke = egui::Stroke::NONE;
|
||
ui.visuals_mut().widgets.inactive.weak_bg_fill = egui::Color32::TRANSPARENT;
|
||
ui.style_mut().text_styles.insert(egui::TextStyle::Monospace, egui::FontId::monospace(t.font_label));
|
||
scalar_field_impl(ui, value, range, mixed, true)
|
||
})
|
||
.inner;
|
||
field.union(track)
|
||
})
|
||
.inner
|
||
}
|
||
|
||
/// Locale-aware bounded scalar field, used for dimensionless material properties.
|
||
pub(crate) fn scalar_field(ui: &mut Ui, value: &mut f64, range: std::ops::RangeInclusive<f64>) -> Response {
|
||
mixed_scalar_field(ui, value, range, None)
|
||
}
|
||
|
||
/// A bounded scalar with a translated mixed-value placeholder. Typing or dragging
|
||
/// replaces the placeholder; commit ownership remains with the caller.
|
||
pub(crate) fn mixed_scalar_field(ui: &mut Ui, value: &mut f64, range: std::ops::RangeInclusive<f64>, mixed: Option<&str>) -> Response {
|
||
scalar_field_impl(ui, value, range, mixed, false)
|
||
}
|
||
|
||
fn scalar_field_impl(ui: &mut Ui, value: &mut f64, range: std::ops::RangeInclusive<f64>, mixed: Option<&str>, plain: bool) -> Response {
|
||
ui.style_mut().drag_value_text_style = egui::TextStyle::Monospace;
|
||
let before = *value;
|
||
let parsed = std::cell::Cell::new(false);
|
||
let field = egui::DragValue::new(value).range(range).speed(0.01).custom_parser(|text| {
|
||
let value = crate::prefs::parse_number(text);
|
||
parsed.set(value.is_some());
|
||
value
|
||
});
|
||
let field = if plain { field.fixed_decimals(2) } else { field };
|
||
let mut response = ui.add_sized(vec2(dimension(ui.available_width()), row_height()), |ui: &mut Ui| {
|
||
let field = if let Some(mixed) = mixed.filter(|_| !ui.ctx().is_being_dragged(ui.next_auto_id())) {
|
||
field.custom_formatter(move |_, _| mixed.to_owned())
|
||
} else {
|
||
field
|
||
};
|
||
ui.add(field)
|
||
});
|
||
// Entering the first target's existing number still sets every mixed target.
|
||
// Merely focusing and leaving the translated placeholder is inert.
|
||
if mixed.is_some() {
|
||
response.flags.set(egui::response::Flags::CHANGED, *value != before || parsed.get());
|
||
}
|
||
if !plain {
|
||
Tokens::get().input_bevel(ui, &response);
|
||
}
|
||
scenario::publish_target(&format!("dialog:scalar:{}", label(ui)), response.rect);
|
||
response
|
||
}
|
||
|
||
/// Length held in millimetres, dragged or typed in the design's units ("0.5 in", "2 cm + 3 mm" parse).
|
||
/// Tokens: control_height, scope control/font tokens.
|
||
pub(crate) fn length_field(ui: &mut Ui, value: &mut f64, units: &str, decimals: u8) -> Response {
|
||
let response = ui.add(length_drag(value, units, decimals));
|
||
Tokens::get().input_bevel(ui, &response);
|
||
scenario::publish_target(&format!("dialog:length:{}", label(ui)), response.rect);
|
||
response
|
||
}
|
||
|
||
/// A model-space length with tool-specific bounds and drag step, shown in design units.
|
||
pub(crate) fn bounded_length_field(
|
||
ui: &mut Ui,
|
||
value: &mut f64,
|
||
units: &str,
|
||
decimals: u8,
|
||
range: std::ops::RangeInclusive<f64>,
|
||
speed: f64,
|
||
) -> Response {
|
||
let response = ui.add(length_drag(value, units, decimals).range(range).speed(speed));
|
||
scenario::publish_target(&format!("dialog:length:{}", label(ui)), response.rect);
|
||
response
|
||
}
|
||
|
||
/// Angle in degrees, dragged or typed. Tokens: control_height, scope control/font tokens.
|
||
pub(crate) fn angle_field(ui: &mut Ui, value: &mut f64) -> Response {
|
||
// An owner that keeps the angle in radians gives back the value the field set a hair off
|
||
// (-3 deg as -2.9999999999999996). The field takes that for a change made elsewhere and
|
||
// rewrites what is being typed from it, which drops a decimal point just typed: "-3." became
|
||
// "-3", and the 7 after it made -37 (#10582). It is given the value it set instead.
|
||
let set = ui.next_auto_id().with("angle_field_set");
|
||
let mut shown = *value;
|
||
if let Some(last) = ui.data(|d| d.get_temp::<f64>(set)).filter(|last| (last - shown).abs() <= 1e-9 * last.abs().max(1.0)) {
|
||
shown = last;
|
||
}
|
||
let response = ui.add(egui::DragValue::new(&mut shown).speed(1.0).suffix(" deg").custom_parser(crate::prefs::parse_number));
|
||
if response.changed() {
|
||
*value = shown;
|
||
ui.data_mut(|d| d.insert_temp(set, shown));
|
||
}
|
||
Tokens::get().input_bevel(ui, &response);
|
||
scenario::publish_target(&format!("dialog:angle:{}", label(ui)), response.rect);
|
||
response
|
||
}
|
||
|
||
/// Bounded multiline data input. Caller owns validation and keyboard semantics.
|
||
/// Tokens: control_height/fill, form_inset, font_label.
|
||
pub(crate) fn text_area(ui: &mut Ui, label: &str, id: egui::Id, value: &mut String, rows: usize, limit: usize) -> Response {
|
||
let t = Tokens::get();
|
||
let mut response = ui.add_sized(
|
||
vec2(dimension(ui.available_width()), row_height() * rows.clamp(1, 16) as f32),
|
||
text_input(egui::TextEdit::multiline(value))
|
||
.id(id)
|
||
.desired_rows(rows.clamp(1, 16))
|
||
.char_limit(limit)
|
||
.font(egui::FontId::monospace(t.font_label))
|
||
.background_color(t.input_fill()),
|
||
);
|
||
super::text_menu::menu(ui, &mut response, value, super::text_menu::Field::LINES.limited(limit));
|
||
t.input_bevel(ui, &response);
|
||
response.widget_info(|| {
|
||
let mut info = egui::WidgetInfo::labeled(egui::WidgetType::TextEdit, ui.is_enabled(), label);
|
||
info.current_text_value = Some(value.clone());
|
||
info
|
||
});
|
||
response
|
||
}
|
||
|
||
/// Secret input with a stable ID. Never publishes its value in accessibility/scenario metadata.
|
||
/// Tokens: cell_editor tokens.
|
||
pub(crate) fn password_field(ui: &mut Ui, id: egui::Id, value: &mut String, hint: &str) -> Response {
|
||
let t = Tokens::get();
|
||
let mut response = ui.add_sized(
|
||
vec2(dimension(ui.available_width()), row_height()),
|
||
text_input(egui::TextEdit::singleline(value))
|
||
.id(id)
|
||
.password(true)
|
||
.hint_text(hint)
|
||
.font(egui::FontId::monospace(t.font_label))
|
||
.background_color(t.input_fill()),
|
||
);
|
||
super::text_menu::menu(ui, &mut response, value, super::text_menu::Field { secret: true, ..super::text_menu::Field::LINE });
|
||
publish(ui, &response, egui::WidgetType::TextEdit);
|
||
response
|
||
}
|
||
|
||
/// Bounded integer or decimal preference with its original drag step and unit suffix.
|
||
/// Tokens: scope control/font tokens. Values and limits are caller data.
|
||
pub(crate) fn number_field<T: egui::emath::Numeric>(
|
||
ui: &mut Ui,
|
||
value: &mut T,
|
||
range: std::ops::RangeInclusive<T>,
|
||
speed: f64,
|
||
suffix: &str,
|
||
) -> Response {
|
||
let response = ui.add(egui::DragValue::new(value).range(range).speed(speed).suffix(suffix).custom_parser(crate::prefs::parse_number));
|
||
if response.has_focus() {
|
||
crate::prefs_search::note_key_sink(ui.ctx());
|
||
}
|
||
Tokens::get().input_bevel(ui, &response);
|
||
response.widget_info(|| {
|
||
let mut info = egui::WidgetInfo::drag_value(ui.is_enabled(), value.to_f64());
|
||
info.label = Some(crate::i18n::tr_label(label(ui)).to_string());
|
||
info
|
||
});
|
||
super::layout::publish_geometry(ui, &response);
|
||
response
|
||
}
|
||
|
||
/// Three bounded numeric components sharing the available control-column width.
|
||
/// Each field retains the standard parser, bevel and focus behaviour. Tokens:
|
||
/// number_field typography/chrome and the enclosing row's spacing.
|
||
pub(crate) fn vector3_field(ui: &mut Ui, values: &mut [f64; 3], range: std::ops::RangeInclusive<f64>, suffix: &str) -> bool {
|
||
let mut changed = false;
|
||
let label = super::layout::label(ui).to_owned();
|
||
ui.columns(3, |columns| {
|
||
for (axis, (ui, value)) in columns.iter_mut().zip(values).enumerate() {
|
||
let width = ui.available_width().max(0.0);
|
||
ui.spacing_mut().text_edit_width = width;
|
||
ui.spacing_mut().interact_size.x = width;
|
||
ui.set_clip_rect(ui.clip_rect().intersect(ui.max_rect()));
|
||
let response = number_field(ui, value, range.clone(), 0.01, suffix);
|
||
scenario::publish_target(&format!("dialog:vector:{label}:{axis}"), response.rect);
|
||
changed |= response.changed();
|
||
}
|
||
});
|
||
changed
|
||
}
|
||
|
||
/// Equal-width numeric cells within a shared `row`. Returns each field's response in order.
|
||
/// Tokens: `control_height`, inherited item spacing and number-field tokens.
|
||
pub(crate) fn number_fields<T: egui::emath::Numeric>(
|
||
ui: &mut Ui,
|
||
values: &mut [T],
|
||
range: std::ops::RangeInclusive<T>,
|
||
speed: f64,
|
||
suffix: &str,
|
||
) -> Vec<Response> {
|
||
let gap = ui.spacing().item_spacing.x;
|
||
let width = dimension(ui.available_width() - gap * values.len().saturating_sub(1) as f32) / values.len().max(1) as f32;
|
||
values
|
||
.iter_mut()
|
||
.enumerate()
|
||
.map(|(index, value)| {
|
||
ui.push_id(index, |ui| {
|
||
ui.allocate_ui_with_layout(vec2(width, row_height()), egui::Layout::top_down_justified(egui::Align::LEFT), |ui| {
|
||
ui.spacing_mut().text_edit_width = width;
|
||
ui.spacing_mut().interact_size.x = width;
|
||
number_field(ui, value, range.clone(), speed, suffix)
|
||
})
|
||
.inner
|
||
})
|
||
.inner
|
||
})
|
||
.collect()
|
||
}
|
||
|
||
/// A number on a range track, without unit: dragged `speed` a point, shown with `decimals`, typed
|
||
/// as a sum of numbers (`relative_number`).
|
||
/// Tokens: scope control/font tokens. Values are caller data.
|
||
pub(crate) fn track_number(ui: &mut Ui, value: &mut f64, speed: f64, decimals: usize) -> Response {
|
||
let now = *value;
|
||
let response = ui.add(egui::DragValue::new(value).speed(speed).fixed_decimals(decimals).custom_parser(move |s| relative_number(s, now)));
|
||
Tokens::get().input_bevel(ui, &response);
|
||
super::layout::publish_geometry(ui, &response);
|
||
response
|
||
}
|
||
|
||
/// A value typed as a sum of numbers (`crate::prefs::parse_number` each), added to `now` when it
|
||
/// starts with a sign: "+30" moves the value by 30, "0-5" is −5.
|
||
fn relative_number(text: &str, now: f64) -> Option<f64> {
|
||
let text: String = text.chars().filter(|c| !c.is_whitespace()).map(|c| if c == '\u{2212}' { '-' } else { c }).collect();
|
||
let mut total = if text.starts_with(['+', '-']) { now } else { 0.0 };
|
||
let mut term = String::new();
|
||
let mut prev = ' ';
|
||
for c in text.chars() {
|
||
if (c == '+' || c == '-') && !term.is_empty() && !matches!(prev, 'e' | 'E') {
|
||
total += crate::prefs::parse_number(&term)?;
|
||
term.clear();
|
||
}
|
||
term.push(c);
|
||
prev = c;
|
||
}
|
||
total += crate::prefs::parse_number(&term)?;
|
||
total.is_finite().then_some(total)
|
||
}
|
||
|
||
/// Growing plain-text message editor; its parent owns scrolling and Enter routing.
|
||
/// Tokens: control_fill, form_inset, font_label. Use text_area for bounded data input.
|
||
#[cfg(any(not(target_arch = "wasm32"), test))]
|
||
pub(crate) fn message_field(ui: &mut Ui, id: egui::Id, value: &mut String, hint: &str) -> Response {
|
||
let t = Tokens::get();
|
||
let mut response = ui.add(
|
||
text_input(egui::TextEdit::multiline(value))
|
||
.id(id)
|
||
.hint_text(hint)
|
||
.desired_rows(2)
|
||
.desired_width(f32::INFINITY)
|
||
.font(egui::FontId::proportional(t.font_label))
|
||
.background_color(t.input_fill()),
|
||
);
|
||
super::text_menu::menu(ui, &mut response, value, super::text_menu::Field::LINES);
|
||
t.input_bevel(ui, &response);
|
||
response
|
||
}
|
||
|
||
/// Edit a millimetre value through a control expressed in the current design units.
|
||
/// Keep the stored value untouched unless the user actually changes the field.
|
||
fn length_drag<'a>(value: &'a mut f64, units: &str, decimals: u8) -> egui::DragValue<'a> {
|
||
let (scale, unit) = crate::prefs::unit_scale(units);
|
||
egui::DragValue::new(value)
|
||
.speed(0.5)
|
||
.suffix(format!(" {unit}"))
|
||
.custom_formatter(move |mm, _| crate::prefs::length_number(mm, unit, decimals))
|
||
.custom_parser(move |text| crate::prefs::parse_length_mm(text, scale))
|
||
}
|
||
|
||
/// Small model-anchored value editor. Retains its focus ID and native hit height so it does
|
||
/// not intercept nearby canvas picks; the owner keeps completion and selection handling.
|
||
/// With `keep_tab` Tab stays with the field (the caller acts on it) instead of moving the
|
||
/// keyboard to the next widget.
|
||
pub(crate) fn canvas_value_field(ui: &mut Ui, id: egui::Id, value: &mut String, keep_tab: bool) -> Response {
|
||
let t = Tokens::get();
|
||
let width = grown_width(ui, value, &egui::TextStyle::Body.resolve(ui.style()), t.space_24 * 3.0);
|
||
// At least that wide: in an area the space left is last frame's width, which can't grow.
|
||
let mut edit = egui::TextEdit::singleline(value).id(id).desired_width(width).min_size(vec2(width, 0.0)).background_color(t.input_fill());
|
||
if keep_tab {
|
||
edit = edit.event_filter(egui::EventFilter { tab: true, horizontal_arrows: true, ..Default::default() });
|
||
}
|
||
let mut response = ui.add(edit);
|
||
super::text_menu::menu(ui, &mut response, value, super::text_menu::Field::LINE);
|
||
t.input_bevel(ui, &response);
|
||
let field = (ui.ctx().cumulative_pass_nr(), response.id, value.chars().count());
|
||
ui.ctx().data_mut(|data| data.insert_temp(egui::Id::new("sc_canvas_value_focus"), field));
|
||
response
|
||
}
|
||
|
||
/// How wide a value field on the canvas is: `base` for a number, as wide as an expression typed
|
||
/// into it (parameter names, a formula), up to three times `base`.
|
||
fn grown_width(ui: &Ui, value: &str, font: &egui::FontId, base: f32) -> f32 {
|
||
let text = ui.fonts_mut(|fonts| fonts.layout_no_wrap(value.to_owned(), font.clone(), egui::Color32::PLACEHOLDER).size().x);
|
||
// Room for the cursor after the last character.
|
||
(text + Tokens::get().space_6).clamp(base, base * 3.0)
|
||
}
|
||
|
||
/// Placement editor whose owner routes Enter and Tab (including rejected expressions).
|
||
/// Completion remains with the caller. Tokens: cell_editor tokens.
|
||
pub(crate) fn placement_field(ui: &mut Ui, id: egui::Id, value: &mut String, hint: &str) -> Response {
|
||
let t = Tokens::get();
|
||
let font = egui::FontId::proportional(t.font_body);
|
||
let size = placement_field_content_size(ui, value);
|
||
let mut response = ui.add(
|
||
text_input(egui::TextEdit::singleline(value))
|
||
.id(id)
|
||
.min_size(size)
|
||
.desired_width(size.x)
|
||
.return_key(None)
|
||
.event_filter(egui::EventFilter { tab: true, horizontal_arrows: true, vertical_arrows: true, ..Default::default() })
|
||
.font(font)
|
||
.background_color(t.input_fill())
|
||
.text_color(t.form_ink)
|
||
.clip_text(true),
|
||
);
|
||
super::text_menu::menu(ui, &mut response, value, super::text_menu::Field::LINE);
|
||
publish(ui, &response, egui::WidgetType::TextEdit);
|
||
response.widget_info(|| {
|
||
let mut info = egui::WidgetInfo::labeled(egui::WidgetType::TextEdit, ui.is_enabled(), crate::i18n::tr_label(hint));
|
||
info.current_text_value = Some(value.clone());
|
||
info
|
||
});
|
||
crate::theme::TabAccent::number_focus(ui, &response);
|
||
t.input_bevel(ui, &response);
|
||
response.backing_on_hover_text(crate::i18n::tr_label(hint))
|
||
}
|
||
|
||
/// Attached Library dropdown and text editor inside one bordered control.
|
||
/// The caller retains draft, completion and commit ownership.
|
||
pub(crate) fn library_cell(ui: &mut Ui, id: egui::Id, value: &mut String, hint: &str, menu: impl FnOnce(&mut Ui)) -> Response {
|
||
let t = Tokens::get();
|
||
let (rect, _) = ui.allocate_exact_size(vec2(dimension(ui.available_width()), row_height()), egui::Sense::hover());
|
||
ui.painter().rect(rect, t.control_radius, t.control_fill, t.control_border_stroke(t.control_border), egui::StrokeKind::Inside);
|
||
let split = (rect.right() - t.space_24).max(rect.left());
|
||
let field = egui::Rect::from_min_max(rect.min, egui::pos2(split, rect.bottom()));
|
||
let response = ui
|
||
.scope_builder(egui::UiBuilder::new().max_rect(field).layout(egui::Layout::left_to_right(egui::Align::Center)), |ui| {
|
||
ui.set_clip_rect(ui.clip_rect().intersect(field));
|
||
cell_editor_frame(ui, id, value, hint, false, usize::MAX, false)
|
||
})
|
||
.inner;
|
||
let button = egui::Rect::from_min_max(egui::pos2(split, rect.top()), rect.max);
|
||
t.secondary_vline(ui.painter(), split, rect.y_range(), t.dialog_rule);
|
||
let library = super::icon_button_at(ui, button, "chevron", "Library");
|
||
scenario::publish_handle("dialog:menu:Library", button.center());
|
||
scenario::publish_rect("dialog:menu:Library", button);
|
||
let popup = Container::new(ui.ctx(), Surface::Popup).menu(&library);
|
||
let open = popup.is_open();
|
||
popup.show(|ui| super::scope(ui, menu));
|
||
if open {
|
||
ui.input_mut(|i| i.consume_key(egui::Modifiers::NONE, egui::Key::Escape));
|
||
}
|
||
if value.is_empty() { response.backing_on_hover_text(crate::i18n::tr_label(hint)) } else { response }
|
||
}
|
||
|
||
/// Inline tree-name editor in caller-owned geometry; preserves its native focus and selection ID.
|
||
/// Tokens: text. The caller retains commit/cancel and select-all behavior.
|
||
pub(crate) fn inline_name(ui: &mut Ui, rect: egui::Rect, id: egui::Id, value: &mut String) -> Response {
|
||
let mut response = ui.put(
|
||
rect,
|
||
egui::TextEdit::singleline(value).id(id).frame(egui::Frame::NONE).text_color(Tokens::get().text).vertical_align(egui::Align::Center),
|
||
);
|
||
super::text_menu::menu(ui, &mut response, value, super::text_menu::Field::LINE);
|
||
response
|
||
}
|
||
|
||
/// The placement editor's content size, before its horizontal text margins and outer frame.
|
||
/// Floating owners use the same measurement to place adjacent editors without overlap.
|
||
pub(crate) fn placement_field_content_size(ui: &Ui, value: &str) -> egui::Vec2 {
|
||
let t = Tokens::get();
|
||
let font = egui::FontId::proportional(t.font_body);
|
||
// Retain the native hit target: a taller editor would intercept nearby sketch picks.
|
||
let height = ui.fonts_mut(|fonts| fonts.row_height(&font)) + ui.spacing().extra_text_line_spacing + t.space_4;
|
||
vec2(grown_width(ui, value, &font, t.control_height * 3.0 - t.space_6), height)
|
||
}
|