shifathosn
/
designcraft
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

X: XML basics — tags, style-to-tag map, structure, export/import, tagged frame markers 

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Brandon Thomas 2026-10-03 03:21:30 -04:00
parent 3f2d53f330
commit d6d9c385ea
17 changed files with 527 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Cargo.lock generated
View File

@ -943,6 +943,7 @@ dependencies = [
"hayro-syntax",
"kurbo",
"log",
"quick-xml 0.38.4",
"regex",
"serde",
"serde_json",

1
ROADMAP.md
View File

@ -75,6 +75,7 @@ DesignCraft aims at full Adobe InDesign parity — and to be better: faster, ope
- Object ▸ Clipping Path (`object.clippingPath {type: alpha|edges, threshold, tolerance}`): traces the placed image and makes the outline the frame.
- Gridify: arrow keys while dragging a frame or shape tool add columns/rows (`frame.grid`), one undo step.
- Gap tool (U, `gap.move`): drag the space between objects (or an object and the page edge) and both sides resize.
- XML basics (`xml.newTag/deleteTag/tag/mapStyle/structure`, `file.exportXml`, `file.importXml`; Tags panel with structure; View ▸ Show Tagged Frames): tagged frames export in reading order, mapped paragraph styles become elements, imported elements flow into frames with matching tags. Inline text tagging and DTDs aren't there yet.
- Drag and drop text editing: drag selected text to move it (Alt copies) with its formatting (`text.release`).
- Image Import Options: place any page of a multi-page PDF (`file.place {pdfPage}`; the app asks which page), shown on screen and embedded as that page in PDF export.
- Define Lists: named numbered lists that continue across stories in page order (`list.define`, paragraph `listName` / `startAt`), round-tripped through IDML; `null` in `type.para` / `type.char` now removes an override.

2
apps/designcraft/src/main.rs
View File

@ -93,6 +93,8 @@ fn services() -> Services {
let d = rfd::FileDialog::new();
let d = if purpose == "swatches" {
d.add_filter("Swatch Exchange (ASE)", &["ase"])
} else if purpose == "xml" {
d.add_filter("XML", &["xml"])
} else if purpose == "library" {
d.add_filter("Object Library", &["dclib"])
} else if purpose == "place" {

1
crates/doc/src/build.rs
View File

@ -132,6 +132,7 @@ impl Document {
inks: Default::default(),
stroke_styles: vec![],
articles: vec![],
xml: Default::default(),
endnote_options: Default::default(),
endnote_story: None,
sections: vec![Section {

4
crates/doc/src/item.rs
View File

@ -712,6 +712,9 @@ pub struct Item {
/// Alternative text (Object Export Options) for tagged PDF and EPUB.
#[serde(default, skip_serializing_if = "String::is_empty")]
pub alt_text: String,
/// XML tag (Tags panel); its content is the element's content in XML export/import.
#[serde(default, skip_serializing_if = "String::is_empty")]
pub xml_tag: String,
/// Groups: Isolate Blending (blend modes only within the group) and Knockout Group (the
/// group's objects don't show through each other).
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
@ -751,6 +754,7 @@ impl Item {
overrides: None,
label: String::new(),
alt_text: String::new(),
xml_tag: String::new(),
isolate: false,
knockout: false,
}

26
crates/doc/src/lib.rs
View File

@ -228,6 +228,29 @@ impl InkManager {
}
}
/// XML tags and mappings.
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", default)]
pub struct XmlSettings {
pub root: String,
pub tags: Vec<XmlTag>,
/// Paragraph style → tag: tagged frames' paragraphs become elements of that name.
pub style_map: Vec<(String, String)>,
}
impl XmlSettings {
pub fn is_empty(&self) -> bool {
self.tags.is_empty() && self.style_map.is_empty() && self.root.is_empty()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct XmlTag {
pub name: String,
pub color: [u8; 3],
}
/// An article: objects in reading order; `export` includes it when exporting.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
@ -418,6 +441,9 @@ pub struct Document {
/// the top level.
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub color_groups: Vec<ColorGroup>,
/// XML: the tags (Tags panel) and the paragraph style → tag map (Map Styles to Tags).
#[serde(default, skip_serializing_if = "XmlSettings::is_empty")]
pub xml: XmlSettings,
/// Articles panel: named reading-order lists of objects (EPUB / HTML export order).
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub articles: Vec<Article>,

1
crates/engine/Cargo.toml
View File

@ -26,6 +26,7 @@ serde_json = { workspace = true }
thiserror = { workspace = true }
log = { workspace = true }
regex = { workspace = true }
quick-xml = { workspace = true }
[dev-dependencies]
zip = { workspace = true }

2
crates/engine/src/cmd/mod.rs
View File

@ -41,6 +41,7 @@ pub mod table;
pub mod text;
mod toc;
mod variables;
mod xml;
mod xref;
use designcraft_doc::{ItemId, SpreadRef};
@ -148,6 +149,7 @@ pub fn command_specs() -> &'static [CommandSpec] {
v.extend(conditions::specs());
v.extend(library::specs());
v.extend(lists::specs());
v.extend(xml::specs());
v.extend(strokes::specs());
v.extend(path_type::specs());
v.extend(qr::specs());

381
crates/engine/src/cmd/xml.rs Normal file
View File

@ -0,0 +1,381 @@
//! Structure and XML: tags on frames (Tags panel), paragraph styles mapped to tags, the structure
//! tree, XML export and import (content flows into the frames with matching tags).
use designcraft_doc::{Content, Document, Item, ItemId, ParaFormat, Story, StoryId, XmlTag};
use serde_json::{Value, json};
use super::{CommandSpec, bad, cmd, has_doc, ids_param, ok, str_param};
use crate::{EngineError, Result, Session};
const COLORS: [[u8; 3]; 6] = [[230, 120, 40], [60, 140, 220], [70, 170, 90], [200, 70, 160], [150, 110, 220], [200, 170, 40]];
fn root_name(d: &Document) -> String {
if d.xml.root.is_empty() { "Root".into() } else { d.xml.root.clone() }
}
fn valid_name(n: &str) -> bool {
let mut c = n.chars();
c.next().is_some_and(|f| f.is_alphabetic() || f == '_') && n.chars().all(|ch| ch.is_alphanumeric() || matches!(ch, '_' | '-' | '.'))
}
/// Tagged objects in reading order (pages, then top to bottom, left to right), nested ones included.
fn tagged(d: &Document) -> Vec<ItemId> {
let mut keyed: Vec<((usize, i64, i64), ItemId)> = Vec::new();
for (si, sp) in d.spreads.iter().enumerate() {
let first = d.first_page_of_spread(si);
for top in &sp.items {
top.walk(&mut |it: &Item| {
if !it.xml_tag.is_empty() {
let b = it.bounds();
let page = first + sp.page_at_x(b.center().x).unwrap_or(0);
keyed.push(((page, (b.y0 * 10.0) as i64, (b.x0 * 10.0) as i64), it.id));
}
});
}
}
keyed.sort_by_key(|(k, _)| *k);
keyed.into_iter().map(|(_, i)| i).collect()
}
fn esc(s: &str) -> String {
s.replace('&', "&amp;").replace('<', "&lt;").replace('>', "&gt;").replace('"', "&quot;")
}
/// Plain text of a story (markers dropped, forced breaks as newlines).
fn plain(t: &str) -> String {
t.chars().filter(|c| !('\u{E000}'..='\u{E1FF}').contains(c)).map(|c| if c == '\u{2028}' { '\n' } else { c }).collect()
}
/// The document's tagged content as XML.
pub fn export_xml(d: &Document) -> String {
let mut out = format!("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n<{}>\n", root_name(d));
for id in tagged(d) {
let Some(it) = d.item(id) else { continue };
let tag = &it.xml_tag;
match &it.content {
Content::Text(tf) => {
let Some(st) = d.story(tf.story) else { continue };
let mapped = |style: &str| d.xml.style_map.iter().find(|(s, _)| s == style).map(|(_, t)| t.clone());
let paras: Vec<(Option<String>, String)> =
st.para_ranges().into_iter().enumerate().map(|(i, r)| (mapped(&st.paras[i].style), plain(&st.text[r]))).collect();
if paras.iter().any(|(m, _)| m.is_some()) {
out.push_str(&format!(" <{tag}>\n"));
for (m, text) in paras {
match m {
Some(t) => out.push_str(&format!(" <{t}>{}</{t}>\n", esc(&text))),
None => out.push_str(&format!(" {}\n", esc(&text))),
}
}
out.push_str(&format!(" </{tag}>\n"));
} else {
out.push_str(&format!(" <{tag}>{}</{tag}>\n", esc(&paras.into_iter().map(|(_, t)| t).collect::<Vec<_>>().join("\n"))));
}
}
Content::Graphic(g) => {
let name = d.assets.get(&g.asset).map(|a| a.link.clone().unwrap_or_else(|| a.name.clone())).unwrap_or_default();
out.push_str(&format!(" <{tag} href=\"file://{}\"/>\n", esc(&name)));
}
_ => out.push_str(&format!(" <{tag}/>\n")),
}
}
out.push_str(&format!("</{}>\n", root_name(d)));
out
}
/// One element under the root: its name and either text or (child name, text) paragraphs.
struct Element {
name: String,
text: String,
children: Vec<(String, String)>,
}
fn parse(xml: &str) -> std::result::Result<Vec<Element>, String> {
use quick_xml::events::Event;
let mut r = quick_xml::Reader::from_str(xml);
let mut depth = 0usize;
let mut out: Vec<Element> = Vec::new();
let mut child: Option<(String, String)> = None;
loop {
match r.read_event().map_err(|e| e.to_string())? {
Event::Start(e) => {
depth += 1;
let name = String::from_utf8_lossy(e.local_name().as_ref()).to_string();
match depth {
2 => out.push(Element { name, text: String::new(), children: vec![] }),
3 => child = Some((name, String::new())),
_ => {}
}
}
Event::Empty(e) if depth == 1 => {
out.push(Element { name: String::from_utf8_lossy(e.local_name().as_ref()).to_string(), text: String::new(), children: vec![] });
}
ev @ (Event::Text(_) | Event::GeneralRef(_) | Event::CData(_)) => {
let s = match ev {
Event::Text(t) => t.decode().map_err(|e| e.to_string())?.to_string(),
Event::CData(t) => String::from_utf8_lossy(&t).to_string(),
Event::GeneralRef(g) => match g.resolve_char_ref().map_err(|e| e.to_string())? {
Some(c) => c.to_string(),
None => match g.decode().map_err(|e| e.to_string())?.as_ref() {
"amp" => "&".into(),
"lt" => "<".into(),
"gt" => ">".into(),
"quot" => "\"".into(),
"apos" => "'".into(),
_ => String::new(),
},
},
_ => unreachable!(),
};
match (depth, child.as_mut(), out.last_mut()) {
(3, Some(c), _) => c.1.push_str(&s),
(2, _, Some(el)) => el.text.push_str(&s),
_ => {}
}
}
Event::End(_) => {
if depth == 3
&& let (Some(c), Some(el)) = (child.take(), out.last_mut())
{
el.children.push(c);
}
depth = depth.saturating_sub(1);
}
Event::Eof => break,
_ => {}
}
}
Ok(out)
}
pub fn specs() -> Vec<CommandSpec> {
vec![
cmd!(query "xml.tags", "Tags", [], None, "{} → {root, tags: [{name, color}], styleMap: [[style, tag]]}", has_doc, |s, _| {
let d = &s.doc()?.doc;
Ok(json!({"root": root_name(d), "tags": d.xml.tags, "styleMap": d.xml.style_map}))
}),
cmd!("xml.newTag", "New Tag", ["Window", "Utilities", "Tags"], None, "{name, color?: [r, g, b]}", has_doc, |s, p| {
let name = str_param(p, "name").unwrap_or("").trim().to_string();
if !valid_name(&name) {
return Err(bad("xml.newTag", format!("`{name}` isn't a valid XML name")));
}
s.edit(|d, _| {
if !d.xml.tags.iter().any(|t| t.name == name) {
let color = COLORS[d.xml.tags.len() % COLORS.len()];
d.xml.tags.push(XmlTag { name: name.clone(), color });
}
Ok(json!({"name": name}))
})
}),
cmd!("xml.deleteTag", "Delete Tag", [], None, "{name} — tagged objects are untagged", has_doc, |s, p| {
let name = str_param(p, "name").unwrap_or("").to_string();
let ids: Vec<ItemId> = {
let d = &s.doc()?.doc;
tagged(d).into_iter().filter(|i| d.item(*i).is_some_and(|it| it.xml_tag == name)).collect()
};
s.edit(|d, _| {
d.xml.tags.retain(|t| t.name != name);
d.xml.style_map.retain(|(_, t)| *t != name);
for id in &ids {
if let Some(it) = d.item_mut(*id) {
it.xml_tag.clear();
}
}
ok()
})
}),
cmd!("xml.tag", "Tag Frame", [], None, "{tag (made if new), ids? (default: the selection)} — `tag: null` untags", has_doc, |s, p| {
let tag = str_param(p, "tag").map(str::to_string);
if let Some(t) = &tag
&& !valid_name(t)
{
return Err(bad("xml.tag", format!("`{t}` isn't a valid XML name")));
}
let ids = ids_param(p, "ids").unwrap_or_else(|| s.active().map(|d| d.selection.items.clone()).unwrap_or_default());
if ids.is_empty() {
return Err(bad("xml.tag", "select objects to tag"));
}
s.edit(|d, _| {
if let Some(t) = &tag
&& !d.xml.tags.iter().any(|x| x.name == *t)
{
let color = COLORS[d.xml.tags.len() % COLORS.len()];
d.xml.tags.push(XmlTag { name: t.clone(), color });
}
for id in &ids {
if let Some(it) = d.item_mut(*id) {
it.xml_tag = tag.clone().unwrap_or_default();
}
}
ok()
})
}),
cmd!(
"xml.mapStyle",
"Map Styles to Tags",
[],
None,
"{style: paragraph style, tag | null} — that style's paragraphs export as `<tag>` elements and import back with it",
has_doc,
|s, p| {
let style = str_param(p, "style").unwrap_or("").to_string();
let tag = str_param(p, "tag").map(str::to_string);
if s.doc()?.doc.styles.para(&style).is_none() {
return Err(bad("xml.mapStyle", format!("no paragraph style `{style}`")));
}
s.edit(|d, _| {
d.xml.style_map.retain(|(st, _)| *st != style);
if let Some(t) = tag {
if !d.xml.tags.iter().any(|x| x.name == t) {
let color = COLORS[d.xml.tags.len() % COLORS.len()];
d.xml.tags.push(XmlTag { name: t.clone(), color });
}
d.xml.style_map.push((style.clone(), t));
}
ok()
})
}
),
cmd!(query "xml.structure", "Structure", [], None, "{} → {root, elements: [{tag, id, kind, text?}]} in reading order", has_doc, |s, _| {
let d = &s.doc()?.doc;
let elements: Vec<Value> = tagged(d)
.into_iter()
.filter_map(|id| d.item(id))
.map(|it| {
let (kind, text) = match &it.content {
Content::Text(tf) => ("text", d.story(tf.story).map(|st| plain(&st.text))),
Content::Graphic(_) => ("graphic", None),
_ => ("object", None),
};
json!({"tag": it.xml_tag, "id": it.id.0, "kind": kind, "text": text})
})
.collect();
Ok(json!({"root": root_name(d), "elements": elements}))
}),
cmd!(noundo "file.exportXml", "Export XML…", ["File"], None, "{path?} — the tagged content in reading order → {path, bytes} (no path: {text})", has_doc, |s, p| {
let text = export_xml(&s.doc()?.doc);
match str_param(p, "path") {
Some(path) => {
#[cfg(not(target_arch = "wasm32"))]
std::fs::write(path, text.as_bytes()).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;
Ok(json!({"path": path, "bytes": text.len()}))
}
None => Ok(json!({"text": text, "bytes": text.len()})),
}
}),
cmd!(
"file.importXml",
"Import XML…",
["File"],
None,
"{path | text} — each element's content goes into the next text frame with that tag (child elements of mapped tags become paragraphs in their style) → {placed, unmatched}",
has_doc,
import_xml
),
]
}
fn import_xml(s: &mut Session, p: &Value) -> Result<Value> {
const ID: &str = "file.importXml";
let text = match (str_param(p, "text"), str_param(p, "path")) {
(Some(t), _) => t.to_string(),
(None, Some(path)) => {
#[cfg(not(target_arch = "wasm32"))]
let t = std::fs::read_to_string(path).map_err(|e| EngineError::Other(format!("{path}: {e}")))?;
#[cfg(target_arch = "wasm32")]
let t = String::new();
t
}
_ => return Err(bad(ID, "`path` or `text` required")),
};
let elements = parse(&text).map_err(|e| bad(ID, format!("not well-formed XML: {e}")))?;
let d = &s.doc()?.doc;
// Frames by tag, in reading order; each element takes the next free one.
let mut slots: Vec<(String, StoryId, bool)> =
tagged(d).into_iter().filter_map(|id| d.item(id)).filter_map(|it| it.text_frame().map(|tf| (it.xml_tag.clone(), tf.story, false))).collect();
let reverse: Vec<(String, String)> = d.xml.style_map.iter().map(|(st, t)| (t.clone(), st.clone())).collect();
let mut fills: Vec<(StoryId, Vec<(Option<String>, String)>)> = Vec::new();
let mut unmatched = 0;
for el in elements {
let Some(slot) = slots.iter_mut().find(|(t, _, used)| *t == el.name && !used) else {
unmatched += 1;
continue;
};
slot.2 = true;
let paras: Vec<(Option<String>, String)> = if el.children.is_empty() {
el.text.trim().split('\n').map(|l| (None, l.trim().to_string())).collect()
} else {
el.children
.into_iter()
.map(|(t, txt)| (reverse.iter().find(|(tag, _)| *tag == t).map(|(_, st)| st.clone()), txt.trim().to_string()))
.collect()
};
fills.push((slot.1, paras));
}
let placed = fills.len();
s.edit(|d, _| {
for (sid, paras) in fills {
let Some(st) = d.story_mut(sid) else { continue };
let base = st.paras.first().cloned().unwrap_or_default();
let text = paras.iter().map(|(_, t)| t.as_str()).collect::<Vec<_>>().join("\n");
let frames = std::mem::take(&mut st.frames);
let mut fresh = Story::with_text(sid, &text, ParaFormat { table: None, ..base.clone() });
for (i, (style, _)) in paras.iter().enumerate() {
if let (Some(sty), Some(pf)) = (style, fresh.paras.get_mut(i)) {
pf.style = sty.clone();
}
}
fresh.frames = frames;
fresh.rev = st.rev + 1;
*st = fresh;
}
Ok(json!({"placed": placed, "unmatched": unmatched}))
})
}
#[cfg(test)]
mod tests {
use serde_json::json;
use crate::Session;
#[test]
fn tag_export_and_import_xml() {
let mut s = Session::new();
s.execute("file.new", &json!({})).unwrap();
s.execute("style.paragraph.create", &json!({"name": "Head"})).unwrap();
let a = s
.execute("frame.create", &json!({"rect": [72, 72, 400, 150], "content": "text", "text": "Title A\nBody & more", "caret": false}))
.unwrap();
s.execute("text.select", &json!({"story": a["story"], "anchor": 0, "focus": 0})).unwrap();
s.execute("style.paragraph.apply", &json!({"name": "Head"})).unwrap();
let b = s.execute("frame.create", &json!({"rect": [72, 300, 400, 350], "content": "text", "text": "Caption", "caret": false})).unwrap();
s.execute("xml.tag", &json!({"tag": "story", "ids": [a["id"]]})).unwrap();
s.execute("xml.tag", &json!({"tag": "caption", "ids": [b["id"]]})).unwrap();
s.execute("xml.mapStyle", &json!({"style": "Head", "tag": "title"})).unwrap();
let x = s.execute("file.exportXml", &json!({})).unwrap()["text"].as_str().unwrap().to_string();
assert!(
x.contains("<story>")
&& x.contains("<title>Title A</title>")
&& x.contains("Body &amp; more")
&& x.contains("<caption>Caption</caption>"),
"{x}"
);
assert!(x.find("<story>").unwrap() < x.find("<caption>").unwrap(), "reading order");
let st = s.execute("xml.structure", &json!({})).unwrap();
assert_eq!(st["elements"].as_array().unwrap().len(), 2);
// Import new content into the same structure.
let r = s
.execute(
"file.importXml",
&json!({"text": "<Root><story><title>New title</title><p>New body</p></story><caption>New caption</caption><extra/></Root>"}),
)
.unwrap();
assert_eq!((r["placed"].as_u64(), r["unmatched"].as_u64()), (Some(2), Some(1)));
let d = &s.doc().unwrap().doc;
let sa = d.stories[&designcraft_doc::StoryId(a["story"].as_u64().unwrap())].clone();
assert_eq!(sa.text, "New title\nNew body");
assert_eq!(sa.paras[0].style, "Head", "mapped tag → paragraph style");
assert_eq!(d.stories[&designcraft_doc::StoryId(b["story"].as_u64().unwrap())].text, "New caption");
assert!(s.execute("xml.tag", &json!({"tag": "1bad", "ids": [b["id"]]})).is_err());
}
}

1
crates/idml/src/import.rs
View File

@ -2091,6 +2091,7 @@ impl<'r> Importer<'r> {
inks: std::mem::take(&mut self.inks),
stroke_styles: std::mem::take(&mut self.stroke_styles),
articles: vec![],
xml: Default::default(),
endnote_options: Default::default(),
endnote_story: None,
sections: std::mem::take(&mut self.sections),

17
crates/ui-egui/src/canvas.rs
View File

@ -609,6 +609,23 @@ fn draw_frames(app: &DesignApp, painter: &egui::Painter, xf: &Xf, doc: &Document
for it in &sp.items {
draw_item_edges(painter, xf, doc, it, a);
}
// Tagged frames in their tag's colour.
if app.ui.tagged_frames {
for top in &sp.items {
top.walk(&mut |it: &Item| {
if it.xml_tag.is_empty() {
return;
}
let Some(t) = doc.xml.tags.iter().find(|t| t.name == it.xml_tag) else { return };
let col = Color32::from_rgb(t.color[0], t.color[1], t.color[2]);
for poly in path_screen(it, xf, a) {
for w in poly.windows(2) {
painter.line_segment([w[0], w[1]], Stroke::new(2.5, col));
}
}
});
}
}
}
}

2
crates/ui-egui/src/dock.rs
View File

@ -36,6 +36,7 @@ pub const ICON_PANELS: &[(&str, &str, &str)] = &[
("hyperlinks", "Hyperlinks", "panel-hyperlinks"),
("bookmarks", "Bookmarks", "panel-bookmarks"),
("articles", "Articles", "panel-articles"),
("tags", "Tags", "panel-tags"),
];
pub fn show(app: &mut DesignApp, ui: &mut egui::Ui) {
@ -177,6 +178,7 @@ pub fn panel_body(app: &mut DesignApp, ui: &mut egui::Ui, id: &str) {
"hyperlinks" => panels::interactive::hyperlinks(app, ui),
"bookmarks" => panels::interactive::bookmarks(app, ui),
"articles" => panels::interactive::articles(app, ui),
"tags" => panels::interactive::tags(app, ui),
"table" => panels::table::show(app, ui),
_ => panels::properties::info_panel(app, ui),
}

6
crates/ui-egui/src/icons.rs
View File

@ -316,6 +316,12 @@ pub fn paint(p: &Painter, r: Rect, name: &str, c: Color32) {
pen.closed(&[(17.0, 10.0), (13.0, 14.0), (10.0, 14.0), (13.0, 11.0), (14.0, 9.0), (13.0, 7.0), (15.0, 6.0)]);
pen.line(&[(8.0, 12.0), (12.0, 8.0)]);
}
"panel-tags" => {
// Angle brackets.
pen.line(&[(7.0, 5.0), (3.0, 10.0), (7.0, 15.0)]);
pen.line(&[(13.0, 5.0), (17.0, 10.0), (13.0, 15.0)]);
pen.line(&[(11.0, 4.0), (9.0, 16.0)]);
}
"panel-articles" => {
// Numbered blocks in order.
pen.rect(3.0, 3.0, 11.0, 8.0);

3
crates/ui-egui/src/lib.rs
View File

@ -97,6 +97,8 @@ pub struct UiState {
pub document_grid: bool,
pub text_threads: bool,
pub hidden_characters: bool,
/// View › Structure › Show Tagged Frames.
pub tagged_frames: bool,
/// View › Display Performance.
pub display_quality: designcraft_render::DisplayQuality,
/// Preferences › Interface › UI scaling (1 = 100%).
@ -156,6 +158,7 @@ impl Default for UiState {
document_grid: false,
text_threads: false,
hidden_characters: false,
tagged_frames: false,
display_quality: designcraft_render::DisplayQuality::High,
ui_scale: 1.0,
rich_black: false,

7
crates/ui-egui/src/menus.rs
View File

@ -19,6 +19,7 @@ pub const UI_COMMANDS: &[(&str, &str, Option<&str>, &str)] = &[
("app.exportIdml", "Export IDML…", None, "{path?} — InDesign Markup (IDML) package"),
("app.exportEpub", "Export EPUB…", None, "{path?} — reflowable EPUB 3"),
("app.exportHtml", "Export HTML…", None, "{path?} — one self-contained web page"),
("app.exportXml", "Export XML…", None, "{path?} — the tagged content"),
("app.printBooklet", "Print Booklet…", None, "{path?} — saddle-stitched printer spreads as PDF"),
("app.qrCode", "Generate QR Code…", None, "{} — the QR Code dialog (object.qrCode does the work)"),
("app.userDictionary", "User Dictionary…", None, "{} — hyphenation exceptions (hyphenation.* commands)"),
@ -59,6 +60,7 @@ pub const UI_COMMANDS: &[(&str, &str, Option<&str>, &str)] = &[
("view.baselineGrid", "Show/Hide Baseline Grid", Some("Cmd+Alt+'"), "{}"),
("view.textThreads", "Show/Hide Text Threads", Some("Cmd+Alt+Y"), "{}"),
("view.hiddenCharacters", "Show/Hide Hidden Characters", Some("Cmd+Alt+I"), "{}"),
("view.taggedFrames", "Show/Hide Tagged Frames", None, "{} — XML-tagged frames outlined in their tag colour"),
("view.overprintPreview", "Overprint Preview", Some("Cmd+Alt+Shift+Y"), "{} — show how overprinting inks mix"),
("view.fastDisplay", "Fast Display", Some("Cmd+Alt+Shift+Z"), "{} — placed graphics as grey boxes, no effects"),
("view.typicalDisplay", "Typical Display", Some("Cmd+Alt+Z"), "{} — low-resolution image proxies"),
@ -118,6 +120,7 @@ pub const MENUS: &[(&str, &[&str])] = &[
"ui:app.exportIdml",
"ui:app.exportEpub",
"ui:app.exportHtml",
"ui:app.exportXml",
"ui:app.exportText",
">Export",
"cmd:snippet.export",
@ -285,6 +288,7 @@ pub const MENUS: &[(&str, &[&str])] = &[
"cmd:type.sizeDown",
"-",
"ui:view.hiddenCharacters",
"ui:view.taggedFrames",
"-",
">Hyperlinks & Cross-References",
"cmd:hyperlink.create",
@ -495,6 +499,7 @@ pub const MENUS: &[(&str, &[&str])] = &[
"ui:window.panel|Hyperlinks|{\"panel\": \"hyperlinks\"}",
"ui:window.panel|Bookmarks|{\"panel\": \"bookmarks\"}",
"ui:window.panel|Articles|{\"panel\": \"articles\"}",
"ui:window.panel|Tags|{\"panel\": \"tags\"}",
"<",
">Utilities",
"cmd:data.merge",
@ -584,6 +589,7 @@ pub fn run_ui(app: &mut DesignApp, id: &str, p: &Value) -> Option<Result<Value,
"app.exportIdml" => export_idml(app, p),
"app.exportEpub" => export_bytes(app, p, "epub", "file.exportEpub"),
"app.exportHtml" => export_bytes(app, p, "html", "file.exportHtml"),
"app.exportXml" => export_bytes(app, p, "xml", "file.exportXml"),
"app.printBooklet" => export_bytes(app, p, "pdf", "file.printBooklet"),
"app.fittingOptions" => {
let g = app.session.active().and_then(|d| d.selection.items.first().and_then(|id| d.doc.item(*id)).and_then(|it| it.graphic().cloned()));
@ -834,6 +840,7 @@ pub fn run_ui(app: &mut DesignApp, id: &str, p: &Value) -> Option<Result<Value,
"view.baselineGrid" => flag(&mut app.ui.baseline_grid),
"view.textThreads" => flag(&mut app.ui.text_threads),
"view.hiddenCharacters" => flag(&mut app.ui.hidden_characters),
"view.taggedFrames" => flag(&mut app.ui.tagged_frames),
"view.goToPage" => {
match p.get("page") {
Some(Value::Number(n)) => crate::canvas::go_to_page(app, (n.as_u64().unwrap_or(1) as usize).saturating_sub(1)),

64
crates/ui-egui/src/panels/interactive.rs
View File

@ -113,3 +113,67 @@ pub fn articles(app: &mut DesignApp, ui: &mut egui::Ui) {
});
}
}
/// Tags panel and structure: tags (click to tag the selection), the structure in reading order,
/// XML export/import.
pub fn tags(app: &mut DesignApp, ui: &mut egui::Ui) {
let t = Tokens::get(ui.ctx());
let Ok(info) = app.session.execute("xml.tags", &json!({})) else { return };
let has_sel = app.session.active().is_some_and(|d| !d.selection.items.is_empty());
let id = egui::Id::new("new_tag_name");
let mut name: String = ui.data(|d| d.get_temp(id)).unwrap_or_default();
ui.horizontal(|ui| {
ui.add(egui::TextEdit::singleline(&mut name).hint_text("New tag").desired_width(140.0));
if ui.button("New").clicked() && !name.trim().is_empty() {
match app.run("xml.newTag", json!({"name": name.trim()})) {
Ok(_) => name.clear(),
Err(e) => app.status(format!("Tags: {e}")),
}
}
});
ui.data_mut(|d| d.insert_temp(id, name));
for tag in info["tags"].as_array().cloned().unwrap_or_default() {
let n = tag["name"].as_str().unwrap_or("").to_string();
let c = tag["color"].as_array().map(|a| a.iter().map(|v| v.as_u64().unwrap_or(0) as u8).collect::<Vec<_>>()).unwrap_or_default();
ui.horizontal(|ui| {
let (r, _) = ui.allocate_exact_size(egui::vec2(12.0, 12.0), egui::Sense::hover());
if c.len() == 3 {
ui.painter().rect_filled(r, 2.0, egui::Color32::from_rgb(c[0], c[1], c[2]));
}
if ui.add_enabled(has_sel, egui::Button::new(&n).frame(false)).on_hover_text("Tag the selection").clicked() {
let _ = app.run("xml.tag", json!({"tag": n}));
}
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
if ui.small_button("Delete").clicked() {
let _ = app.run("xml.deleteTag", json!({"name": n}));
}
});
});
}
if has_sel && ui.small_button("Untag Selection").clicked() {
let _ = app.run("xml.tag", json!({"tag": null}));
}
ui.separator();
ui.label(egui::RichText::new("Structure").strong());
let st = app.session.execute("xml.structure", &json!({})).unwrap_or_default();
ui.label(egui::RichText::new(st["root"].as_str().unwrap_or("Root")).size(11.0).color(t.text_dim));
for el in st["elements"].as_array().cloned().unwrap_or_default() {
let text = el["text"].as_str().unwrap_or("").chars().take(40).collect::<String>();
let label = format!(" <{}> {}", el["tag"].as_str().unwrap_or(""), text);
if ui.selectable_label(false, egui::RichText::new(label).size(11.0)).clicked() {
let _ = app.run("selection.set", json!({"ids": [el["id"]]}));
}
}
ui.separator();
ui.horizontal(|ui| {
if ui.button("Export XML…").clicked() {
let _ = app.run("app.exportXml", json!({}));
}
if ui.button("Import XML…").clicked()
&& let Some(path) = app.services.pick_open.as_mut().and_then(|f| f("xml"))
&& let Err(e) = app.run("file.importXml", json!({"path": path}))
{
app.status(format!("Import XML: {e}"));
}
});
}

16
docs/parity.md
View File

@ -11,7 +11,7 @@ Each row of the InDesign feature catalogue is scored **D** (done), **P** (partia
|---|---|---|---|---|---|
| P0 | 102 | 99 | 3 | 0 | 99% |
| P1 | 97 | 92 | 4 | 1 | 97% |
| P2 | 76 | 27 | 14 | 35 | 45% |
| P2 | 76 | 27 | 18 | 31 | 47% |
| Area | Parity |
|---|---|
@ -29,9 +29,9 @@ Each row of the InDesign feature catalogue is scored **D** (done), **P** (partia
| Tables | 92% |
| Long documents | 88% |
| Interactivity & digital | 75% |
| Output & production | 75% |
| XML & automation | 61% |
| View & navigation | 86% |
| Output & production | 78% |
| XML & automation | 72% |
| View & navigation | 88% |
| Undo, history, saving | 100% |
| Accessibility | 70% |
@ -286,10 +286,10 @@ Open P0 items: Preferences, Vector/page formats (PDF/AI/SVG/EPS place), Export t
| Output & production | Export IDML | P0 | D |
| Output & production | Export EPUB/HTML | P2 | P |
| Output & production | Export RTF/TXT/Tagged text | P2 | P |
| Output & production | Export XML | P2 | M |
| Output & production | Export XML | P2 | P |
| Output & production | Separations / Flattener / Ink limit preview | P2 | M |
| XML & automation | Tags panel, Structure | P2 | M |
| XML & automation | Import/Export XML | P2 | M |
| XML & automation | Tags panel, Structure | P2 | P |
| XML & automation | Import/Export XML | P2 | P |
| XML & automation | Data Merge | P2 | D |
| XML & automation | Scripts panel | P2 | P |
| XML & automation | Script Label | P2 | D |
@ -303,7 +303,7 @@ Open P0 items: Preferences, Vector/page formats (PDF/AI/SVG/EPS place), Export t
| View & navigation | Overprint preview | P1 | D |
| View & navigation | Rulers, guides, grids toggles | P0 | D |
| View & navigation | Show/hide frame edges, threads, hidden chars | P0 | D |
| View & navigation | Structure / tag markers | P2 | M |
| View & navigation | Structure / tag markers | P2 | P |
| View & navigation | Display performance | P0 | D |
| View & navigation | Navigate pages | P0 | D |
| View & navigation | Split window | P2 | M |