GitCorner

Code

ossartcraftvectorcraft🌐
2bc41aeb8602
use super::labels::{PreviousLabel, label_field, name_field, take_previous_label};
use super::numeric::mixed_field_named;
use super::panel_chrome::{
    alt_down_in_field, chevron_cell, entry_to_focus, keep_enter_in_presets, open_presets_from_keys, presets_open, return_focus_from_presets,
};
use super::{Rect, Response, Stroke, StrokeKind, Tokens, Ui, id_with, vec2};

/// The flag `dialogs::show` raises while it draws the body of a dialog that has just opened; the
/// first enabled field drawn takes it ([`take_dialog_focus`]).
pub(crate) fn dialog_focus_flag() -> egui::Id {
    egui::Id::unique("dialog-focus-first-field")
}

/// If field `id` (showing `text`) is the first enabled field of a dialog that has just opened, give
/// it the keyboard focus with all of `text` selected: typing replaces the value and Enter applies it.
pub(crate) fn take_dialog_focus(ui: &Ui, id: egui::Id, text: &str) {
    // A new window's first frame only measures its contents: nothing can take focus yet. Nor can a
    // greyed-out field (egui drops its focus): the flag stays for the first field that is enabled.
    if ui.is_sizing_pass() || !ui.is_enabled() || ui.data_mut(|d| d.remove_temp::<bool>(dialog_focus_flag())).is_none() {
        return;
    }
    focus_field(ui, id, text);
}

/// Give text field `id` the keyboard focus with all of `text` selected.
pub(crate) fn focus_field(ui: &Ui, id: egui::Id, text: &str) {
    select_all(ui, id, text);
    ui.memory_mut(|m| m.request_focus(id));
}

/// The key under which [`arm_field_focus`] keeps the armed field's id salt.
fn armed_field_flag() -> egui::Id {
    egui::Id::unique("armed-field-focus")
}

/// Arm the field drawn with id salt `salt`: a numeric field's `id`, or a searchable menu's (the
/// font family menu's). The next one drawn, enabled and outside a sizing pass, takes the keyboard
/// focus ([`take_armed_focus`]) until [`disarm_field_focus`].
pub(crate) fn arm_field_focus(ctx: &egui::Context, salt: impl std::hash::Hash) {
    ctx.data_mut(|d| d.insert_temp(armed_field_flag(), id_with(egui::Id::NULL, salt)));
}

/// Disarm the field [`arm_field_focus`] armed. → Whether it was still armed: no field took it.
pub(crate) fn disarm_field_focus(ctx: &egui::Context) -> bool {
    ctx.data_mut(|d| {
        let armed = d.get_temp::<egui::Id>(armed_field_flag()).is_some();
        d.remove::<egui::Id>(armed_field_flag());
        armed
    })
}

/// Whether the field drawn with id salt `salt` is the one armed and can take the keyboard focus
/// now (it is enabled, and this is not a sizing pass). It is then disarmed.
pub(crate) fn take_armed_focus(ui: &Ui, salt: impl std::hash::Hash) -> bool {
    if ui.is_sizing_pass() || !ui.is_enabled() {
        return false;
    }
    let salt = id_with(egui::Id::NULL, salt);
    ui.data_mut(|d| {
        let armed = d.get_temp::<egui::Id>(armed_field_flag()) == Some(salt);
        if armed {
            d.remove::<egui::Id>(armed_field_flag());
        }
        armed
    })
}

/// The modifiers held with an Enter press among this frame's events, `None` without one, as when a
/// field's editing ends with a click elsewhere.
pub(crate) fn enter_modifiers(ui: &Ui) -> Option<egui::Modifiers> {
    ui.input(|i| {
        i.events.iter().find_map(|e| match e {
            egui::Event::Key { key: egui::Key::Enter, pressed: true, modifiers, .. } => Some(*modifiers),
            _ => None,
        })
    })
}

/// Select all of `text` in text field `id`.
pub(super) fn select_all(ui: &Ui, id: egui::Id, text: &str) {
    let mut st = egui::TextEdit::load_state(ui.ctx(), id).unwrap_or_default();
    let all = egui::text::CCursorRange::two(egui::text::CCursor::new(0), egui::text::CCursor::new(text.chars().count()));
    st.cursor.set_char_range(Some(all));
    st.store(ui.ctx(), id);
}

/// The flag that tells the fields a dialog is open in this frame ([`set_dialog_open`]).
fn dialog_open_flag() -> egui::Id {
    egui::Id::unique("dialog-open")
}

/// The flag that tells the dialog runner a field rejected an invalid commit on Enter in this frame.
pub(crate) fn dialog_reject_commit_flag() -> egui::Id {
    egui::Id::unique("dialog-reject-commit")
}

/// The pass (`cumulative_pass_nr`) in which a field last rejected an invalid commit: a click on a
/// dialog's OK whose press came at or before it doesn't confirm the dialog.
pub(crate) fn dialog_reject_pass() -> egui::Id {
    egui::Id::unique("dialog-reject-pass")
}

/// Suppress confirming an open dialog on Enter during this frame, or by the click on OK that took
/// the focus from the field, when an invalid value was committed.
pub(crate) fn reject_dialog_commit(ctx: &egui::Context) {
    let pass = ctx.cumulative_pass_nr();
    ctx.data_mut(|d| {
        d.insert_temp(dialog_reject_commit_flag(), true);
        d.insert_temp(dialog_reject_pass(), pass);
    });
}

/// The app sets this at the start of each frame: while a dialog is open, Shift+Enter in a field
/// applies its value and confirms the dialog as Enter does ([`shift_enter_keeps_focus`]).
pub(crate) fn set_dialog_open(ctx: &egui::Context, open: bool) {
    ctx.data_mut(|d| d.insert_temp(dialog_open_flag(), open));
}

/// Shift+Enter (Shift+Return) in single-line field `id` while it has the keyboard focus and no
/// dialog is open: the press is taken from this frame's events before the field's text box reads
/// them, so the field keeps the focus. Returns true when it was pressed; the field then applies its
/// text as Enter does, and in the next frame shows its value with all of it selected
/// ([`after_shift_enter`]).
pub(super) fn shift_enter_keeps_focus(ui: &Ui, id: egui::Id) -> bool {
    if !ui.memory(|m| m.has_focus(id)) || ui.data(|d| d.get_temp::<bool>(dialog_open_flag())).unwrap_or(false) {
        return false;
    }
    let pressed = ui.input_mut(|i| {
        let before = i.events.len();
        i.events.retain(|e| {
            !matches!(e, egui::Event::Key { key: egui::Key::Enter, pressed: true, modifiers, .. } if modifiers.matches_exact(egui::Modifiers::SHIFT))
        });
        i.events.len() < before
    });
    if pressed {
        ui.data_mut(|d| d.insert_temp(id.with("shift-enter"), true));
    }
    pressed
}

/// Whether field `id`, still focused, took Shift+Enter in the last frame
/// ([`shift_enter_keeps_focus`]). Clears that record.
pub(super) fn after_shift_enter(ui: &Ui, id: egui::Id) -> bool {
    ui.data_mut(|d| d.remove_temp::<bool>(id.with("shift-enter"))).unwrap_or(false) && ui.memory(|m| m.has_focus(id))
}

/// Handles Shift+Enter in a single-line panel field that draws its own text box `id` (Pattern
/// Options' Name, the inline renames in the Layers, Artboards and Asset Export panels). Call it
/// before the box is drawn, with `buf` the text the box will show and `shown` the value as it is
/// now. When the field took Shift+Enter in the last frame, `buf` becomes `shown`, all of it
/// selected. Returns whether Shift+Enter was pressed in this frame ([`shift_enter_keeps_focus`]):
/// the field then applies `buf` as Enter does and keeps the focus.
pub(crate) fn own_field_shift_enter(ui: &Ui, id: egui::Id, buf: &mut String, shown: &str) -> bool {
    if after_shift_enter(ui, id) {
        *buf = shown.to_string();
        select_all(ui, id, buf);
    }
    shift_enter_keeps_focus(ui, id)
}

/// How far, in points, a focus click may move between press and release and still be a tap that
/// selects the whole numeric value. Covers pen and trackpad jitter; anything further is a drag.
const TAP_SLOP: f32 = 1.0;

/// Numeric fields select the whole text on keyboard focus, a completed focus click or a
/// double-click. A pointer press keeps its caret so dragging selects from the pressed position,
/// and a short drag the toolkit still counts as a click keeps it too (#1326): only a tap
/// (released within [`TAP_SLOP`] of its press) releases into select-all.
pub(super) fn select_all_on_focus(ui: &Ui, resp: &Response, text: &str) {
    let pending = resp.id.with("select-all-on-focus-click");
    let press_pos = resp.id.with("select-all-on-focus-press");
    let (pressed, released, at_press) = ui.input(|i| {
        (i.pointer.button_pressed(egui::PointerButton::Primary), i.pointer.button_released(egui::PointerButton::Primary), i.pointer.interact_pos())
    });
    if resp.gained_focus() {
        ui.data_mut(|d| {
            if pressed {
                d.insert_temp(pending, true);
                if let Some(p) = at_press {
                    d.insert_temp(press_pos, p);
                }
            } else {
                d.remove_temp::<bool>(pending);
                d.remove_temp::<egui::Pos2>(press_pos);
            }
        });
    }
    let clicked_focus = released && ui.data_mut(|d| d.remove_temp::<bool>(pending)).unwrap_or(false) && resp.clicked_by(egui::PointerButton::Primary);
    // A pointer released more than a point from its press is a drag, not a tap. egui still
    // reports a click for a movement under its click tolerance, and a release inside one
    // character leaves no text selection, so select-all on release would replace the drag the
    // user just made (#1326). The one point of slack keeps a jittery pen or trackpad tap a tap.
    let dragged = clicked_focus
        && ui
            .data_mut(|d| d.remove_temp::<egui::Pos2>(press_pos))
            .is_some_and(|p0| ui.input(|i| i.pointer.interact_pos()).is_some_and(|p1| (p1 - p0).length() > TAP_SLOP));
    if resp.lost_focus() {
        ui.data_mut(|d| {
            d.remove_temp::<bool>(pending);
            d.remove_temp::<egui::Pos2>(press_pos);
        });
    }
    // Returning from a transient menu resumes its saved caret/selection. This is not the
    // keyboard focus that starts a new numeric edit; pointer taps/double-clicks still select all.
    // The menu helper's data borrow ends here, before TextEdit's state is loaded below.
    let restored_focus = crate::menus::restoring_field_focus(ui.ctx(), resp.id);
    if !(resp.gained_focus() && !pressed && !restored_focus || resp.double_clicked() || clicked_focus && !dragged) {
        return;
    }
    if let Some(st) = egui::TextEdit::load_state(ui.ctx(), resp.id) {
        // Preserve a text selection if the focus click already produced one.
        if clicked_focus && !resp.double_clicked() && st.cursor.char_range().is_some_and(|r| !r.as_sorted_char_range().is_empty()) {
            return;
        }
        select_all(ui, resp.id, text);
        ui.ctx().request_repaint();
    }
}

/// The recessed text box of the panel fields showing `shown`, `rows` lines tall (1: single line),
/// its text kept under `id` while it has focus. Returns the text (as edited), whether the field
/// applies it in this frame (it lost the focus, or a single-line field took Shift+Enter and kept
/// the focus: [`shift_enter_keeps_focus`]), the text edit's response and the box.
pub(super) fn recessed_text(
    ui: &mut Ui,
    id: egui::Id,
    shown: &str,
    width: f32,
    rows: usize,
    label: Option<PreviousLabel>,
    name: Option<&str>,
) -> (String, bool, Response, Rect) {
    let t = Tokens::get(ui.ctx());
    let editing = ui.memory(|m| m.has_focus(id));
    // A press outside the field ends its editing in this frame, so the text typed is committed
    // before the press acts: the canvas, drawn after the panels, may select another object, and a
    // frame later the text would be committed to that one.
    if editing
        && let Some(at) = ui.input(|i| i.pointer.primary_pressed().then(|| i.pointer.interact_pos()).flatten())
        && ui.ctx().read_response(id).is_some_and(|r| !r.rect.contains(at))
    {
        ui.memory_mut(|m| m.surrender_focus(id));
    }
    // When the value changes under a focused field (the slider beside it, a preview, another
    // field's edit), its text follows: the text typed for the old value would otherwise go back in
    // on the next Enter, Tab or arrow key (#1457).
    let shown_id = id.with("shown");
    let followed = ui.data_mut(|d| d.get_temp::<String>(shown_id)).is_none_or(|before| before == shown);
    ui.data_mut(|d| d.insert_temp(shown_id, shown.to_string()));
    // A press elsewhere can end the focus outside this field's own drawing (a field drawn before it
    // takes it, the canvas ends text input), so `editing` is already false on the frame it reports
    // `lost_focus`: the text typed is still taken then, to be committed (#1637). Escape drops it.
    let focus_id = id.with("had-focus");
    let had_focus = ui.data_mut(|d| d.get_temp::<bool>(focus_id)).unwrap_or(false) && !ui.input(|i| i.key_pressed(egui::Key::Escape));
    // After Shift+Enter applied the text, the field shows the value as it is now, all selected.
    let reshown = after_shift_enter(ui, id);
    let typed = if (editing || had_focus) && followed && !reshown { ui.data_mut(|d| d.get_temp::<String>(id)) } else { None };
    let mut buf: String = typed.unwrap_or_else(|| shown.to_string());
    if reshown {
        select_all(ui, id, &buf);
    }
    let kept = rows == 1 && shift_enter_keeps_focus(ui, id);
    // The box is exactly as tall as the other controls of a row (26 points a line), its text
    // centred in it: a frame around the text came out a point taller and stood out next to
    // spinners and dropdowns (#900).
    let height = 26.0 + 16.0 * (rows.max(1) - 1) as f32;
    let layout = if rows > 1 { egui::Layout::top_down(egui::Align::Min) } else { egui::Layout::left_to_right(egui::Align::Center) };
    let (rect, resp) = ui
        .allocate_ui_with_layout(vec2(width, height), layout, |ui| {
            ui.set_min_size(vec2(width, height));
            let rect = ui.max_rect();
            let now = ui.input(|i| i.time);
            let flash_end = ui.data(|d| d.get_temp::<f64>(id.with("invalid-flash")));
            let invalid = flash_end.is_some_and(|end| now <= end);
            if invalid {
                ui.ctx().request_repaint();
            }
            let stroke = if invalid {
                Stroke::new(1.5, t.accent_strong)
            } else if editing {
                Stroke::new(1.0, t.accent)
            } else {
                Stroke::new(1.0, t.input_border)
            };
            ui.painter().rect(rect, 5.0, t.input, stroke, StrokeKind::Inside);
            let margin = egui::Margin { left: 7, right: 7, top: if rows > 1 { 4 } else { 0 }, bottom: 0 };
            let resp = egui::Frame::NONE
                .inner_margin(margin)
                .show(ui, |ui| {
                    crate::theme::strong_selected_text(ui);
                    let edit = if rows > 1 {
                        egui::TextEdit::multiline(&mut buf).desired_rows(rows)
                    } else {
                        egui::TextEdit::singleline(&mut buf).align(egui::Align2::LEFT_CENTER)
                    };
                    ui.add(
                        edit.id(id)
                            .frame(egui::Frame::NONE)
                            .margin(egui::Margin::ZERO)
                            .desired_width(width - 14.0)
                            .font(egui::FontId::proportional(12.5))
                            .text_color(t.text_strong),
                    )
                })
                .inner;
            (rect, resp)
        })
        .inner;
    let resp = name_field(label_field(resp, label), name);
    let focused = ui.memory(|m| m.has_focus(id));
    ui.data_mut(|d| {
        d.insert_temp(id, buf.clone());
        d.insert_temp(focus_id, focused);
    });
    // Plain Enter only: Ctrl/Cmd+Enter keeps editing a field that takes it (X and Y in Transform).
    let enter_commit = rows == 1 && editing && ui.input(|i| i.key_pressed(egui::Key::Enter) && i.modifiers.is_none());
    let commit = resp.lost_focus() || kept || enter_commit;
    (buf, commit, resp, rect)
}

/// A recessed text field showing `value` (blank when `None`: the selection's values differ),
/// `rows` lines tall (1: single line, which Enter and Shift+Enter commit). Returns the new text,
/// trimmed, when a change is committed (Enter, Shift+Enter or focus loss).
pub fn text_field(ui: &mut Ui, id: impl std::hash::Hash, value: Option<&str>, width: f32, rows: usize) -> Option<String> {
    text_field_named(ui, id, None, value, width, rows)
}

/// [`text_field`] for a row named explicitly instead of by an adjacent label widget.
pub fn text_field_named(ui: &mut Ui, id: impl std::hash::Hash, name: Option<&str>, value: Option<&str>, width: f32, rows: usize) -> Option<String> {
    let label = take_previous_label(ui);
    let id = id_with(ui.scope_id(), id);
    let shown = value.unwrap_or_default();
    let (buf, commit, _, _) = recessed_text(ui, id, shown, width, rows, label, name);
    (commit && buf.trim() != shown).then(|| buf.trim().to_string())
}

/// A one-line [`text_field`] that keeps the text exactly as typed, spaces included (a tab
/// leader such as ". "). Returns it when a change is committed (Enter, Shift+Enter or focus loss).
pub fn exact_text_field(ui: &mut Ui, id: impl std::hash::Hash, value: &str, width: f32) -> Option<String> {
    exact_text_field_named(ui, id, None, value, width)
}

/// [`exact_text_field`] for a row named explicitly instead of by an adjacent label widget.
pub fn exact_text_field_named(ui: &mut Ui, id: impl std::hash::Hash, name: Option<&str>, value: &str, width: f32) -> Option<String> {
    let label = take_previous_label(ui);
    let id = id_with(ui.scope_id(), id);
    let (buf, commit, _, _) = recessed_text(ui, id, value, width, 1, label, name);
    (commit && buf != value).then_some(buf)
}

/// A plain number field (percent, degrees, counts) with optional suffix.
pub fn plain_field(ui: &mut Ui, id: impl std::hash::Hash, value: f64, suffix: &str, decimals: usize, width: f32) -> Option<f64> {
    plain_field_named(ui, id, None, value, suffix, decimals, width)
}

/// [`plain_field`] for a row named explicitly instead of by an adjacent label widget.
pub fn plain_field_named(
    ui: &mut Ui,
    id: impl std::hash::Hash,
    name: Option<&str>,
    value: f64,
    suffix: &str,
    decimals: usize,
    width: f32,
) -> Option<f64> {
    mixed_field_named(ui, id, name, Some(value), suffix, decimals, width)
}

/// A recessed search field with an italic `hint` (Layers' Search All, Swatches' Find), keeping its
/// text in egui memory under `id`. Returns the text.
pub fn search_field(ui: &mut Ui, id: egui::Id, hint: &str) -> String {
    let t = Tokens::get(ui.ctx());
    let mut query: String = ui.data(|d| d.get_temp(id)).unwrap_or_default();
    egui::Frame::NONE
        .fill(t.input)
        .stroke(Stroke::new(1.0, t.input_border))
        .corner_radius(egui::CornerRadius::same(2))
        .inner_margin(egui::Margin::symmetric(8, 5))
        .show(ui, |ui| {
            ui.add(
                egui::TextEdit::singleline(&mut query)
                    .id(id.with("edit"))
                    .frame(egui::Frame::NONE)
                    .align(egui::Align2::LEFT_CENTER)
                    .hint_text(egui::RichText::new(tl!(hint)).italics())
                    .desired_width(ui.available_width()),
            );
        });
    ui.data_mut(|d| d.insert_temp(id, query.clone()));
    query
}

/// A [`text_field`] with a preset list on its right (Export for Screens' sizes: `2x`, `100w`…).
/// Returns the new text when a change is committed (Enter or focus loss) or a preset is picked.
pub fn text_presets(ui: &mut Ui, id: impl std::hash::Hash, value: &str, presets: &[&str], width: f32) -> Option<String> {
    text_presets_named(ui, id, None, value, presets, width)
}

/// [`text_presets`] for a row whose heading names it instead of an adjacent label widget.
pub fn text_presets_named(ui: &mut Ui, id: impl std::hash::Hash, name: Option<&str>, value: &str, presets: &[&str], width: f32) -> Option<String> {
    let mut out = None;
    ui.scope(|ui| {
        // The field and the chevron share a border.
        ui.spacing_mut().item_spacing.x = -1.0;
        let at = ui.cursor().min;
        let keyed = alt_down_in_field(ui, Rect::from_min_size(at, vec2(width - 19.0, 26.0)));
        out = text_field_named(ui, &id, name, Some(value), width - 19.0, 1);
        let resp = chevron_cell(ui, 26.0);
        let keyed = open_presets_from_keys(ui, &resp, keyed);
        let was_open = presets_open(ui, &resp);
        egui::Popup::menu(&resp).show(|ui| {
            ui.set_min_width(width - 10.0);
            let focus = entry_to_focus(keyed, presets.iter().map(|p| *p == value));
            for (i, p) in presets.iter().enumerate() {
                let r = ui.selectable_label(*p == value, *p);
                if focus == Some(i) {
                    r.request_focus();
                }
                if r.clicked() {
                    out = Some((*p).to_string());
                    // Enter or Space on the focused entry is a click too, which the menu does not
                    // close on by itself.
                    ui.close();
                }
            }
        });
        keep_enter_in_presets(ui, was_open);
        return_focus_from_presets(ui, &resp);
    });
    out
}