6ef13b2cc8a6
inspector.rs
use super::{Stroke, Tokens, Ui, Value, WordApp, json, regular, semibold, vec2};
/// Style Inspector: the paragraph and character levels at the caret, each with its style and the
/// direct formatting on top, and a button to clear each level.
pub(super) fn inspector(app: &mut WordApp, ui: &mut Ui) {
// Read-only, so call it directly: running the command every frame would pay for the command
// machinery and consume per-command state (a pending `join_next_undo`) just to draw the pane.
let r = wordcraft_engine::cmd::inspector::inspect(&app.session);
let t = Tokens::get(ui.ctx());
let none = tl!("None").to_string();
let para = &r["paragraph"];
let chr = &r["character"];
let pstyle = para["styleName"].as_str().unwrap_or("Normal").to_string();
let cstyle = chr["styleName"].as_str().map(str::to_string);
// Built-in style names show in the interface language; the document keeps the English ones.
let shown = |id: &Value, name: &str| {
id.as_str().and_then(|id| app.session.doc.styles.get(id)).map(crate::i18n::style_name).unwrap_or_else(|| name.to_string())
};
let pstyle_shown = shown(¶["style"], &pstyle);
let cstyle_shown = cstyle.as_deref().map(|n| shown(&chr["style"], n));
let pdirect = direct_list(¶["direct"]);
let cdirect = direct_list(&chr["direct"]);
let mut clear: Option<&str> = None;
egui::ScrollArea::vertical().show(ui, |ui| {
section(ui, &t, "Paragraph", |ui| {
if level_row(ui, &t, "Style", &pstyle_shown, false, "Reset to Normal", pstyle == "Normal" && para["style"] == "Normal") {
clear = Some("paragraphStyle");
}
let (txt, empty) = if pdirect.is_empty() { (none.clone(), true) } else { (pdirect.join(", "), false) };
if level_row(ui, &t, "Direct formatting", &txt, empty, "Clear Paragraph Formatting", empty) {
clear = Some("paragraphFormatting");
}
});
ui.add_space(8.0);
section(ui, &t, "Characters", |ui| {
let (txt, empty) = match &cstyle_shown {
Some(n) => (n.clone(), false),
None => (none.clone(), true),
};
if level_row(ui, &t, "Style", &txt, empty, "Clear Character Style", empty) {
clear = Some("characterStyle");
}
let (txt, empty) = if cdirect.is_empty() { (none.clone(), true) } else { (cdirect.join(", "), false) };
if level_row(ui, &t, "Direct formatting", &txt, empty, "Clear Character Formatting", empty) {
clear = Some("characterFormatting");
}
});
ui.add_space(10.0);
ui.horizontal(|ui| {
if ui.button(tl!("Clear All")).on_hover_text(tl!("Clear All Formatting")).clicked() {
let _ = app.run("format.clear", json!({}));
app.canvas.want_focus = true;
}
if ui.button(tl!("Styles Pane")).clicked() {
let _ = app.run("view.stylesPane", json!({"value": true}));
}
});
});
if let Some(level) = clear {
let _ = app.run("styles.inspectorClear", json!({"level": level}));
app.canvas.want_focus = true;
}
}
/// A titled, bordered group in the inspector.
fn section(ui: &mut Ui, t: &Tokens, title: &str, body: impl FnOnce(&mut Ui)) {
ui.label(egui::RichText::new(tl!(title)).font(semibold(12.5)).color(t.text));
ui.add_space(2.0);
egui::Frame::NONE.fill(t.input).stroke(Stroke::new(1.0, t.border)).corner_radius(4).inner_margin(8).show(ui, |ui| {
ui.set_width(ui.available_width());
body(ui);
});
}
/// One level: a caption, its value, and a clear button (disabled when there's nothing to clear).
/// Returns true when the button was clicked.
fn level_row(ui: &mut Ui, t: &Tokens, caption: &str, value: &str, dim: bool, tip: &str, disabled: bool) -> bool {
ui.label(egui::RichText::new(tl!(caption)).font(regular(11.0)).color(t.text_dim));
let mut clicked = false;
ui.horizontal(|ui| {
let w = (ui.available_width() - 26.0).max(40.0);
ui.allocate_ui(vec2(w, 18.0), |ui| {
ui.set_width(w);
let text = egui::RichText::new(value).font(regular(12.5)).color(if dim { t.text_disabled } else { t.text });
ui.add(egui::Label::new(text).wrap());
});
ui.with_layout(crate::rtl::far_side(ui, egui::Align::Min), |ui| {
let (r, resp) = ui.allocate_exact_size(vec2(22.0, 20.0), egui::Sense::click());
let enabled = !disabled;
if enabled && resp.hovered() {
ui.painter().rect_filled(r, 3.0, t.hover);
}
let c = if enabled { t.icon } else { t.text_disabled };
crate::icons::paint(
ui.painter(),
egui::Rect::from_center_size(r.center(), vec2(16.0, 16.0)),
"clear",
c,
if enabled { t.accent } else { c },
);
let resp = resp.on_hover_text(tl!(tip));
clicked = enabled && resp.clicked();
});
});
ui.add_space(4.0);
clicked
}
/// Readable descriptions of the inspector's `direct` entries (`[{"prop", "value"}]`).
fn direct_list(v: &Value) -> Vec<String> {
v.as_array().map(|a| a.iter().take(64).map(|d| describe(d["prop"].as_str().unwrap_or(""), &d["value"])).collect()).unwrap_or_default()
}
/// Each `{"prop", "value"}` of a list (the Style Inspector's, or a formatting change's) as text.
pub(crate) fn describe_props(list: &[Value]) -> Vec<String> {
list.iter().take(64).map(|d| describe(d["prop"].as_str().unwrap_or(""), &d["value"])).collect()
}
/// "Bold", "Not Italic", "Font: Arial", "Size: 14 pt"โฆ
fn describe(prop: &str, v: &Value) -> String {
let label = match prop {
"font" => "Font",
"size" => "Size",
"bold" => "Bold",
"italic" => "Italic",
"underline" => "Underline",
"underlineColor" => "Underline color",
"strike" => "Strikethrough",
"doubleStrike" => "Double strikethrough",
"color" => "Font color",
"highlight" => "Highlight",
"shading" => "Shading",
"vertAlign" => "Position",
"caps" => "All caps",
"smallCaps" => "Small caps",
"hidden" => "Hidden",
"spacing" => "Character spacing",
"scale" => "Scale",
"position" => "Raised/lowered",
"outline" => "Outline",
"shadow" => "Shadow",
"emboss" => "Emboss",
"engrave" => "Engrave",
"align" => "Alignment",
"indentLeft" => "Left indent",
"indentRight" => "Right indent",
"indentFirst" => "First line",
"spaceBefore" => "Space before",
"spaceAfter" => "Space after",
"lineSpacing" => "Line spacing",
"contextualSpacing" => "Don't add space between paragraphs of the same style",
"mirrorIndents" => "Mirror indents",
"keepNext" => "Keep with next",
"keepLines" => "Keep lines together",
"pageBreakBefore" => "Page break before",
"widowControl" => "Widow/Orphan control",
"outlineLevel" => "Outline level",
"tabs" => "Tabs",
"borders" => "Borders",
"suppressHyphens" => "Don't hyphenate",
"suppressLineNumbers" => "Suppress line numbers",
"bidi" => "Right-to-left",
"dropCap" => "Drop cap",
"dropCapMargin" => "In margin",
"dropCapDistance" => "Distance from text",
"dropCapFont" => "Font",
"style" => "Style",
"numbering" => "Numbering",
"lang" => "Language",
other => other,
};
let label = tl!(label);
let pt = |x: f64| crate::i18n::fmt(tl!("{n} pt"), &[("n", &trim_num(x))]);
let hex = |c: &Value| -> Option<String> {
let a = c.as_array()?;
let ch = |i: usize| a.get(i).and_then(Value::as_u64).unwrap_or(0).min(255);
Some(format!("#{:02X}{:02X}{:02X}", ch(0), ch(1), ch(2)))
};
let value = match (prop, v) {
(_, Value::Bool(true)) => return label.to_string(),
(_, Value::Bool(false)) => return crate::i18n::fmt(tl!("Not {name}"), &[("name", label)]),
("scale", Value::Number(n)) => format!("{}%", trim_num(n.as_f64().unwrap_or(100.0))),
("outlineLevel", Value::Number(n)) => match n.as_u64().unwrap_or(9) {
l @ 0..=8 => crate::i18n::fmt(tl!("Level {n}"), &[("n", &(l + 1).to_string())]),
_ => tl!("Body Text").to_string(),
},
("dropCapFont", Value::String(s)) => s.clone(),
("dropCap", Value::Number(n)) => crate::i18n::fmt(tl!("{n} lines"), &[("n", &n.to_string())]),
(_, Value::Number(n)) => pt(n.as_f64().unwrap_or(0.0)),
("align", Value::String(s)) => tl!(match s.as_str() {
"center" => "Centered",
"right" => "Right",
"justify" => "Justified",
"distribute" => "Distributed",
_ => "Left",
})
.to_string(),
("color", Value::String(_)) => tl!("Automatic").to_string(),
("color", Value::Object(o)) => o.get("Rgb").and_then(hex).unwrap_or_default(),
(_, Value::Array(_)) if prop != "tabs" => hex(v).unwrap_or_default(),
("lineSpacing", Value::Object(o)) => {
let x = o.get("value").and_then(Value::as_f64).unwrap_or(1.0);
match o.get("rule").and_then(Value::as_str) {
Some("atLeast") => crate::i18n::fmt(tl!("At least {n}"), &[("n", &pt(x))]),
Some("exactly") => crate::i18n::fmt(tl!("Exactly {n}"), &[("n", &pt(x))]),
_ => crate::i18n::fmt(tl!("{n} lines"), &[("n", &trim_num(x))]),
}
}
(_, Value::String(s)) => tl!(&camel_words(s)).to_string(),
_ => return label.to_string(),
};
format!("{label}: {value}")
}
/// `1.50` โ `1.5`, `12.0` โ `12`.
fn trim_num(x: f64) -> String {
let s = format!("{:.2}", if x.is_finite() { x } else { 0.0 });
s.trim_end_matches('0').trim_end_matches('.').to_string()
}
/// `dotDash` โ `Dot dash` (enum values from the document model).
fn camel_words(s: &str) -> String {
let mut out = String::with_capacity(s.len() + 4);
for (i, c) in s.chars().take(64).enumerate() {
if i == 0 {
out.extend(c.to_uppercase());
} else if c.is_uppercase() {
out.push(' ');
out.extend(c.to_lowercase());
} else {
out.push(c);
}
}
out
}
No file is open. Choose one in the tree, or press Ctrl+O (โO on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.