88f5a00e389b
tool_overlays.rs
use super::frames::{item_canvas_xf, selection_color};
use super::page_decor::dashed;
use super::render::c32;
use super::{CanvasLayout, Color32, Content, DesignApp, Document, Overlay, Point, Pos2, Rect, Stroke, StrokeKind, Tokens, Xf, pos2, vec2};
pub(super) fn draw_tool_overlays(app: &mut DesignApp, painter: &egui::Painter, xf: &Xf) {
if let (Some((z, c)), Some(rect)) = (app.power_zoom, app.canvas_rect) {
// The view that releasing returns to.
let (w, h) = (rect.width() as f64 / z, rect.height() as f64 / z);
let r = xf.rect(designcraft_geom::Rect::new(c.x - w / 2.0, c.y - h / 2.0, c.x + w / 2.0, c.y + h / 2.0));
painter.rect_stroke(r, 0.0, egui::Stroke::new(1.5, Color32::from_rgb(230, 40, 40)), egui::StrokeKind::Middle);
}
let tok = Tokens::get(painter.ctx());
let ov = app.session.overlays(app.view_info());
let doc = app.session.active().map(|st| st.doc.clone());
let layout = app.session.layout();
let sel_color = selection_color(app);
for o in ov {
match o {
Overlay::Marquee(r) => {
let r = xf.rect(r);
painter.rect_filled(r, 0.0, Color32::from_rgba_unmultiplied(80, 140, 255, 30));
for (a, b) in [
(r.left_top(), r.right_top()),
(r.right_top(), r.right_bottom()),
(r.right_bottom(), r.left_bottom()),
(r.left_bottom(), r.left_top()),
] {
dashed(painter, a, b, Stroke::new(1.0, Color32::from_gray(200)), 3.0, 3.0);
}
}
Overlay::Measure { p, text } => {
let s = xf.to_screen(p) + vec2(14.0, 14.0);
let g = painter.layout_no_wrap(text, egui::FontId::proportional(11.0), tok.readout_text);
let r = Rect::from_min_size(s, g.size() + vec2(10.0, 6.0));
painter.rect_filled(r, 3.0, tok.readout_bg);
painter.galley(r.min + vec2(5.0, 3.0), g, tok.readout_text);
}
Overlay::Line { a, b, color, dashed: d } => {
let st = Stroke::new(1.0, c32(color));
if d {
dashed(painter, xf.to_screen(a), xf.to_screen(b), st, 3.0, 3.0);
} else {
painter.line_segment([xf.to_screen(a), xf.to_screen(b)], st);
}
}
Overlay::Guide { a, b } => {
painter.line_segment([xf.to_screen(a), xf.to_screen(b)], Stroke::new(1.0, tok.smart_guide));
}
Overlay::Gap { a, b, label } => {
let (a, b) = (xf.to_screen(a), xf.to_screen(b));
painter.line_segment([a, b], Stroke::new(1.0, tok.smart_guide));
let s = a + (b - a) * 0.5;
let g = painter.layout_no_wrap(label, egui::FontId::proportional(11.0), tok.measure_text);
let r = Rect::from_min_size(s, g.size() + vec2(10.0, 6.0));
painter.rect_filled(r, 3.0, tok.measure_bg);
painter.galley(r.min + vec2(5.0, 3.0), g, tok.measure_text);
}
Overlay::Path { path, color, dashed: d } => draw_path_overlay(painter, xf, &path, c32(color), d),
Overlay::ContentGhost(id) => {
if let Some(doc) = &doc {
draw_content_ghost(painter, xf, doc, &layout, id);
}
}
Overlay::LiveCornerWidget(p) => {
let r = Rect::from_center_size(xf.to_screen(p), vec2(6.0, 6.0));
painter.rect_filled(r, 0.0, tok.live_corner);
painter.rect_stroke(r, 0.0, Stroke::new(1.0, sel_color), StrokeKind::Inside);
}
Overlay::LiveCornerDiamond(p) => {
let c = xf.to_screen(p);
let h = 4.5;
let pts = vec![c + vec2(0.0, -h), c + vec2(h, 0.0), c + vec2(0.0, h), c + vec2(-h, 0.0)];
painter.add(egui::Shape::convex_polygon(pts, tok.live_corner, Stroke::new(1.0, sel_color)));
}
Overlay::PageHandles(r) => {
// The Page tool's selected page: outline and eight handles, as InDesign draws them.
let r = xf.rect(r);
let col = Color32::from_rgb(79, 153, 255);
painter.rect_stroke(r, 0.0, Stroke::new(1.0, col), StrokeKind::Middle);
for i in (0..9).filter(|i| *i != 4) {
let c = pos2(r.min.x + r.width() * (i % 3) as f32 / 2.0, r.min.y + r.height() * (i / 3) as f32 / 2.0);
let h = Rect::from_center_size(c, vec2(7.0, 7.0));
painter.rect_filled(h, 0.0, Color32::WHITE);
painter.rect_stroke(h, 0.0, Stroke::new(1.0, col), StrokeKind::Inside);
}
}
Overlay::Tag { p, text } => {
let text = crate::i18n::tr(&app.ui.language, &text).to_owned();
let s = xf.to_screen(p);
let g = painter.layout_no_wrap(text, egui::FontId::proportional(10.0), tok.measure_text);
let r = Rect::from_min_size(s - vec2(0.0, g.size().y + 4.0), g.size() + vec2(8.0, 4.0));
painter.rect_filled(r, 2.0, tok.measure_bg);
painter.rect_stroke(r, 2.0, Stroke::new(1.0, Color32::from_rgb(79, 153, 255)), StrokeKind::Inside);
painter.galley(r.min + vec2(4.0, 2.0), g, tok.measure_text);
}
Overlay::Tip { p, text } => {
let text = crate::i18n::tr(&app.ui.language, &text).to_owned();
let s = xf.to_screen(p) + vec2(14.0, 14.0);
let g = painter.layout(text, egui::FontId::proportional(11.0), tok.measure_text, 260.0);
let r = Rect::from_min_size(s, g.size() + vec2(10.0, 6.0));
painter.rect_filled(r, 3.0, tok.measure_bg);
painter.galley(r.min + vec2(5.0, 3.0), g, tok.measure_text);
}
Overlay::LiquidPins { object, page, pins, resize } => draw_liquid_pins(painter, xf.rect(object), xf.rect(page), pins, resize),
}
}
}
/// A path overlay (canvas coordinates; the Pencil's stroke while drawing, the Smooth and Erase
/// drags) as screen polylines, its curves flattened to about a quarter of a screen pixel.
fn draw_path_overlay(painter: &egui::Painter, xf: &Xf, path: &designcraft_geom::BezPath, color: Color32, dashed_line: bool) {
use designcraft_geom::PathEl;
let stroke = Stroke::new(1.0, color);
let mut runs: Vec<Vec<Pos2>> = Vec::new();
designcraft_geom::kurbo::flatten(path, 0.25 / xf.zoom.max(1e-9), |el| match el {
PathEl::MoveTo(p) => runs.push(vec![xf.to_screen(p)]),
PathEl::LineTo(p) => {
if let Some(run) = runs.last_mut() {
run.push(xf.to_screen(p));
}
}
PathEl::ClosePath => {
if let Some(run) = runs.last_mut()
&& let Some(&first) = run.first()
{
run.push(first);
}
}
// Flattening yields only moves, lines and closes.
PathEl::QuadTo(..) | PathEl::CurveTo(..) => {}
});
for run in runs.into_iter().filter(|r| r.len() >= 2) {
if dashed_line {
painter.extend(egui::Shape::dashed_line(&run, stroke, 3.0, 3.0));
} else {
painter.add(egui::Shape::line(run, stroke));
}
}
}
/// A frame's whole content drawn faintly over the canvas, the part outside the frame included,
/// with its bounds outlined (while the content moves inside the frame).
fn draw_content_ghost(painter: &egui::Painter, xf: &Xf, doc: &Document, layout: &CanvasLayout, id: designcraft_doc::ItemId) {
let Some(it) = doc.item(id) else { return };
let Some((a, _)) = item_canvas_xf(doc, layout, id) else { return };
let outline = Stroke::new(1.0, Color32::from_rgb(196, 111, 43));
let Content::Graphic(g) = &it.content else {
for c in it.children() {
let r = xf.rect((a * it.xf).transform_rect_bbox(c.bounds()));
painter.rect_stroke(r, 0.0, outline, StrokeKind::Middle);
}
return;
};
let m = a * it.xf * g.xf;
let (w, h) = g.size;
let corners = [Point::new(0.0, 0.0), Point::new(w, 0.0), Point::new(w, h), Point::new(0.0, h)].map(|p| xf.to_screen(m * p));
if corners.iter().any(|p| !p.x.is_finite() || !p.y.is_finite()) {
return;
}
if let Some(tex) = ghost_texture(painter.ctx(), doc, g) {
let mut mesh = egui::Mesh::with_texture(tex.id());
let tint = Color32::from_white_alpha(90);
for (p, uv) in corners.iter().zip([pos2(0.0, 0.0), pos2(1.0, 0.0), pos2(1.0, 1.0), pos2(0.0, 1.0)]) {
mesh.vertices.push(egui::epaint::Vertex { pos: *p, uv, color: tint });
}
mesh.indices.extend([0, 1, 2, 0, 2, 3]);
painter.add(egui::Shape::mesh(mesh));
}
painter.add(egui::Shape::closed_line(corners.to_vec(), outline));
}
/// A screen-resolution proxy of a placed graphic for the ghost, cached per asset.
fn ghost_texture(ctx: &egui::Context, doc: &Document, g: &designcraft_doc::Graphic) -> Option<egui::TextureHandle> {
let asset = doc.assets.get(&g.asset)?;
// A 72 ppi proxy is enough for a faint preview.
super::proxy_texture(ctx, "content_ghost", &asset.data, asset.page, g.size.0, 1.0, 4096)
}
/// An object's liquid controls on an object-based page, as InDesign draws them in orange: a
/// dashed line across the object for width and height with a padlock (closed: locked), and a pin
/// outside each edge (pinned: a line to the page edge).
fn draw_liquid_pins(painter: &egui::Painter, o: Rect, page: Rect, pins: [bool; 4], resize: [bool; 2]) {
let col = Color32::from_rgb(178, 88, 18);
let st = Stroke::new(1.5, col);
let c = o.center();
let mids = [pos2(c.x, o.min.y), pos2(o.max.x, c.y), pos2(c.x, o.max.y), pos2(o.min.x, c.y)];
// The width and height lines between the edges' middles.
for (a, b) in [(mids[3], mids[1]), (mids[0], mids[2])] {
dashed(painter, a, b, Stroke::new(1.0, col), 3.0, 3.0);
}
for m in mids {
painter.circle_filled(m, 3.5, col);
}
let (po, lo) = (designcraft_tools::PIN_OFFSET_PX as f32, designcraft_tools::LOCK_OFFSET_PX as f32);
let outward = [vec2(0.0, -1.0), vec2(1.0, 0.0), vec2(0.0, 1.0), vec2(-1.0, 0.0)];
let edge = [pos2(c.x, page.min.y), pos2(page.max.x, c.y), pos2(c.x, page.max.y), pos2(page.min.x, c.y)];
for i in 0..4 {
if pins[i] {
painter.line_segment([mids[i], edge[i]], st);
painter.circle_filled(edge[i], 4.0, col);
} else {
painter.circle_stroke(mids[i] + outward[i] * po, 4.0, st);
}
}
// Padlocks: the width lock right of the centre, the height lock above it.
for (at, locked) in [(c + vec2(lo, 0.0), !resize[0]), (c + vec2(0.0, -lo), !resize[1])] {
let body = Rect::from_center_size(at + vec2(0.0, 2.0), vec2(8.0, 6.0));
painter.rect_filled(body.expand(1.0), 1.0, Color32::WHITE);
painter.rect_filled(body, 1.0, col);
// The shackle: over the body when locked, swung open when not.
let base = if locked { body.center().x } else { body.center().x + 3.0 };
let pts: Vec<_> = (0..=8)
.map(|k| {
let a = std::f32::consts::PI * k as f32 / 8.0;
pos2(base - 2.6 * a.cos(), body.min.y - 3.0 * a.sin())
})
.collect();
painter.add(egui::Shape::line(pts, Stroke::new(1.3, col)));
}
}
#[cfg(test)]
mod pencil_preview_tests {
use egui::{Pos2, pos2, vec2};
/// Lines painted in `color` (egui paths) and the points they pass through.
fn lines_in(h: &egui_kittest::Harness<'static, crate::test_window::Window>, color: egui::Color32) -> Vec<Vec<Pos2>> {
fn walk(s: &egui::Shape, color: egui::Color32, out: &mut Vec<Vec<Pos2>>) {
match s {
egui::Shape::Path(p) if p.stroke.color == egui::epaint::ColorMode::Solid(color) && p.points.len() >= 2 => out.push(p.points.clone()),
egui::Shape::Vec(v) => v.iter().for_each(|s| walk(s, color, out)),
_ => {}
}
}
let mut out = vec![];
h.output().shapes.iter().for_each(|s| walk(&s.shape, color, &mut out));
out
}
#[test]
fn the_pencil_stroke_shows_while_drawing() {
let mut app = crate::DesignApp::new(designcraft_engine::Session::new(), crate::Services::default());
app.run("file.new", serde_json::json!({})).unwrap();
app.run("tool.select", serde_json::json!({"tool": "pencil"})).unwrap();
let mut h = crate::test_window::open(app, vec2(1400.0, 900.0));
let doc = &h.state().app.session.doc().unwrap().doc;
let layer = doc.layers[0].color;
let color = egui::Color32::from_rgb(layer[0], layer[1], layer[2]);
let items = |h: &egui_kittest::Harness<'static, crate::test_window::Window>| h.state().app.session.doc().unwrap().doc.spreads[0].items.len();
let before = items(&h);
// Press on the page and drag, without letting go.
let start = pos2(520.0, 380.0);
h.hover_at(start);
h.drag_at(start);
h.run_steps(2);
let path: Vec<Pos2> = (1..=12).map(|i| start + vec2(i as f32 * 12.0, (i as f32 * 0.6).sin() * 30.0)).collect();
for p in &path {
h.hover_at(*p);
h.run_steps(1);
}
let drawn = lines_in(&h, color);
let stroke = drawn.iter().max_by_key(|l| l.len()).expect("the stroke is painted while the button is down");
let near = |a: Pos2, b: Pos2| (a - b).length() < 2.0;
assert!(near(stroke[0], start), "it starts where the press was: {:?}", stroke[0]);
assert!(path.iter().all(|p| stroke.iter().any(|q| near(*p, *q))), "it follows the pointer: {stroke:?}");
assert_eq!(items(&h), before, "nothing is made before the release");
// Letting go makes the path and ends the preview.
h.drop_at(*path.last().unwrap());
h.run_steps(3);
assert_eq!(items(&h), before + 1);
let app = &mut h.state_mut().app;
let view = app.view_info();
assert!(app.session.overlays(view).is_empty(), "the preview is gone");
}
}
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.