6ef13b2cc8a6
pages.rs
use super::{DocLayout, Hash, Hasher, Page, Placed, Pos, Pos2, Rect, StoryRef, WordApp, json, pos2};
/// Fingerprint of everything outside the layout that changes how pages render: the view's
/// marks and markup, dark mode, the page colour and watermark, header/body dimming, the media,
/// and (while a drag lasts) the object left out of the page.
/// Taken once per frame.
pub(super) fn view_key(app: &WordApp, dim_body: bool, hidden: Option<&Pos>, hinted: bool) -> u64 {
let mut h = std::collections::hash_map::DefaultHasher::new();
// A page drawn unhinted mid-zoom must not pass for the hinted page (see [`hint_pages`]).
hinted.hash(&mut h);
let v = &app.session.view;
(v.marks, app.session.prefs.marks, v.show_markup, v.dark_mode, wordcraft_render::DARK_PAPER, v.hide_ink, v.draw.replay).hash(&mut h);
(v.read_mode, v.read_page_color, app.session.prefs.paper_color).hash(&mut h);
app.session.prefs.markup.hash(&mut h);
dim_body.hash(&mut h);
format!("{:?}{:?}{:?}", app.session.doc.settings.page_color, app.session.doc.settings.page_picture, app.session.doc.settings.watermark)
.hash(&mut h);
app.session.doc.media.len().hash(&mut h);
// A page drawn without a dragged object must not pass for the page with it: the drag starts
// and ends change the key once each, so the page is rendered again then and only then.
hidden.hash(&mut h);
h.finish()
}
/// Fingerprint of a page's laid-out content. A layout never changes once made, so this is
/// taken once per page and layout ([`PageKeys`]), not every frame.
pub(super) fn page_content_key(page: &Page) -> u64 {
let mut h = std::collections::hash_map::DefaultHasher::new();
(page.w.to_bits(), page.h.to_bits()).hash(&mut h);
for list in [&page.items, &page.header, &page.footer] {
list.len().hash(&mut h);
for it in list.iter() {
match it {
Placed::Lines { para, l0, l1, x, y, turn, .. } => {
(std::sync::Arc::as_ptr(para) as usize, l0, l1, x.to_bits(), y.to_bits(), turn).hash(&mut h);
}
Placed::Fill { rect, color } => format!("{rect:?}{color:?}").hash(&mut h),
Placed::Rule { x0, y0, x1, y1, border } => format!("{x0}{y0}{x1}{y1}{border:?}").hash(&mut h),
Placed::Image { rect, media, crop, spin, fx, .. } => format!("{rect:?}{media}{crop:?}{spin:?}{fx:?}").hash(&mut h),
Placed::Shape { rect, kind, fill, stroke, stroke_width, effects, freeform, spin, extra, .. } => {
format!("{rect:?}{kind:?}{fill:?}{stroke:?}{stroke_width}{effects:?}{spin:?}{extra:?}").hash(&mut h);
freeform.as_ref().map(|f| std::sync::Arc::as_ptr(f) as usize).hash(&mut h);
}
Placed::Graphic { rect, graphic, spin, .. } => {
(std::sync::Arc::as_ptr(graphic) as usize, rect.x.to_bits(), rect.y.to_bits(), rect.w.to_bits(), rect.h.to_bits()).hash(&mut h);
format!("{spin:?}").hash(&mut h)
}
Placed::Clip { rect, spin, items } => format!("{rect:?}{spin:?}{items:?}").hash(&mut h),
Placed::Cell { .. } | Placed::Object { .. } => {}
}
}
}
h.finish()
}
/// The content fingerprints of one layout's pages, taken when a page is first needed (#811).
/// Hashing every item of every page each frame cost tens of milliseconds a frame in a long
/// table (thousands of cell borders per page), idle or scrolling.
#[derive(Default)]
pub(crate) struct PageKeys {
/// The layout these are for; held so its address can't be reused by another one.
pub(super) layout: Option<std::sync::Arc<DocLayout>>,
keys: Vec<Option<u64>>,
/// Pages fingerprinted since the layout last changed.
pub(crate) hashed: usize,
}
impl PageKeys {
fn content(&mut self, layout: &std::sync::Arc<DocLayout>, i: usize) -> u64 {
if !self.layout.as_ref().is_some_and(|l| std::sync::Arc::ptr_eq(l, layout)) {
self.layout = Some(layout.clone());
self.keys = vec![None; layout.pages.len()];
self.hashed = 0;
}
if let Some(Some(k)) = self.keys.get(i) {
return *k;
}
let k = layout.pages.get(i).map_or(0, page_content_key);
if let Some(slot) = self.keys.get_mut(i) {
*slot = Some(k);
self.hashed += 1;
}
k
}
}
/// What page `i` shows, whatever its size: its content and the view (`view_key` with the
/// hinting fixed). A raster that showed this may be stretched to stand in for the page.
pub(super) fn page_shows(app: &mut WordApp, layout: &std::sync::Arc<DocLayout>, i: usize, view: u64) -> u64 {
let mut h = std::collections::hash_map::DefaultHasher::new();
(view, app.canvas.page_keys.content(layout, i)).hash(&mut h);
h.finish()
}
/// The texture cache key of page `i`: its content, the view, and the raster scale.
pub(super) fn page_key(app: &mut WordApp, layout: &std::sync::Arc<DocLayout>, i: usize, view: u64, scale_px: f32) -> u64 {
let mut h = std::collections::hash_map::DefaultHasher::new();
(view, scale_px.to_bits(), app.canvas.page_keys.content(layout, i)).hash(&mut h);
h.finish()
}
pub(super) fn to_screen(origin: Pos2, page_rect: Rect, scale: f32, x: f32, y: f32) -> Pos2 {
pos2(origin.x + page_rect.min.x + x * scale, origin.y + page_rect.min.y + y * scale)
}
/// A page raster as an egui image. Both hold premultiplied RGBA8, so the pixels go across as they
/// are: un-premultiplying them for egui to premultiply again gave the same image for two more
/// passes over every pixel of the page, on each keystroke.
pub(super) fn page_image(img: &wordcraft_render::Rendered) -> egui::ColorImage {
egui::ColorImage::from_rgba_premultiplied([img.width as usize, img.height as usize], &img.pixels)
}
/// Place a raster at a physical-pixel-aligned origin and its exact device-pixel size.
pub(super) fn texel_aligned_rect(layout: Rect, texture_px: egui::Vec2, ppp: f32) -> Rect {
let snap = |v: f32| (v * ppp).round() / ppp;
Rect::from_min_size(pos2(snap(layout.min.x), snap(layout.min.y)), texture_px / ppp)
}
/// Tile indices intersecting the view, in a fixed grid of raster pixels. The grid follows the
/// document, not the viewport, so scrolling never changes tile contents or their cache keys.
pub(super) fn visible_tiles(page_rect: Rect, clip: Rect, screen_scale: f32, raster_scale: f32, tile_height_px: usize) -> std::ops::Range<usize> {
if !page_rect.intersects(clip)
|| !screen_scale.is_finite()
|| !raster_scale.is_finite()
|| screen_scale <= 0.0
|| raster_scale <= 0.0
|| tile_height_px == 0
{
return 0..0;
}
let total_px = (page_rect.height() / screen_scale * raster_scale).ceil() as usize;
let count = total_px.div_ceil(tile_height_px);
let at = |y: f32| ((y - page_rect.min.y).clamp(0.0, page_rect.height()) / screen_scale * raster_scale) / tile_height_px as f32;
let first = (at(clip.top()).floor() as usize).min(count);
let last = (at(clip.bottom()).ceil() as usize).min(count);
first..last.max(first)
}
pub(crate) fn page_screen_scale(rect: Rect, page: &Page, fallback: f32) -> f32 {
if page.w > 0.0 { rect.width() / page.w } else { fallback }
}
/// Closest the drawing grid's lines get on screen; zoomed far out, every other line is skipped.
pub(super) const DRAWING_GRID_MIN_PX: f32 = 4.0;
/// Most grid lines drawn each way on one page (page sizes come from files).
pub(super) const DRAWING_GRID_MAX_LINES: usize = 2000;
/// The View › Gridlines drawing grid over a page's text area, in document points: the x of each
/// vertical line and the y of each horizontal line, starting at the margins and `step` (across,
/// down) apart, never outside the margins. Drawn on screen only — never printed or exported.
pub(super) fn drawing_grid(body: wordcraft_geom::Rect, step: (f32, f32)) -> (Vec<f32>, Vec<f32>) {
let axis = |start: f32, len: f32, step: f32| -> Vec<f32> {
if !(step.is_finite() && step > 0.0 && start.is_finite() && len.is_finite() && len >= 0.0) {
return Vec::new();
}
let end = start + len + 0.01;
(0..DRAWING_GRID_MAX_LINES).map(|k| start + k as f32 * step).take_while(|p| *p <= end).collect()
};
(axis(body.x, body.w, step.0), axis(body.y, body.h, step.1))
}
/// Global View Gridlines outlines every table (#1628). While editing a header/footer, also
/// outline that story's cells (#2197), without adding printable borders or changing the view flag.
pub(super) fn gridline_cells(page: &Page, all: bool, editing: Option<StoryRef>) -> impl Iterator<Item = wordcraft_geom::Rect> + '_ {
// Automatic header/footer guides need not scan a potentially large body placement list.
let body = if all { page.items.as_slice() } else { &[] };
body.iter().chain(&page.header).chain(&page.footer).filter_map(move |it| match it {
Placed::Cell { rect, covered: false, story, .. } if all || Some(*story) == editing => Some(*rect),
_ => None,
})
}
/// The table gridline segments to draw on a page, in document points: the edges of the
/// [`gridline_cells`] minus the parts a printed border already draws. Word shows gridlines only
/// where a cell has no border; drawn over a border, the thin blue guide tinted every bordered
/// table blue and made its lines look uneven when zoomed out (#5967).
pub(super) fn gridline_segments(page: &Page, all: bool, editing: Option<StoryRef>) -> Vec<(wordcraft_geom::Point, wordcraft_geom::Point)> {
use wordcraft_geom::Point;
// A rule this close to a cell edge (points) is drawn on it.
const ON_EDGE: f32 = 0.25;
// Rules by the line they run along (horizontal or not, coordinate in quarter points), so
// each cell edge looks only at the rules on its own line. Body rules cannot cover header or
// footer cells, so they are left out when only those are outlined, as in `gridline_cells`.
let key = |c: f32| (c * 4.0).round() as i64;
let body = if all { page.items.as_slice() } else { &[] };
let mut rules: std::collections::HashMap<(bool, i64), Vec<(f32, f32, f32)>> = std::collections::HashMap::new();
for it in body.iter().chain(&page.header).chain(&page.footer) {
let Placed::Rule { x0, y0, x1, y1, border } = it else { continue };
if !border.is_visible() {
continue;
}
let (horizontal, c0, c1, s0, s1) = if (y0 - y1).abs() <= ON_EDGE { (true, *y0, *y1, *x0, *x1) } else { (false, *x0, *x1, *y0, *y1) };
if (c0 - c1).abs() <= ON_EDGE && c0.is_finite() {
rules.entry((horizontal, key(c0))).or_default().push((c0, s0.min(s1), s0.max(s1)));
}
}
// The rules covering the line at `at`, sorted and merged into disjoint spans. Cells share their
// edges, so each distinct line is sorted once (not once per cell edge) and every edge then
// binary-searches its start.
let mut merged: std::collections::HashMap<(bool, u32), Vec<(f32, f32)>> = std::collections::HashMap::new();
// The parts of [a, b] along a line at `at` that no rule on the same line covers; `horizontal`
// picks rules running along x at y = `at`, otherwise along y at x = `at`.
let mut uncovered = |horizontal: bool, at: f32, a: f32, b: f32| -> Vec<(f32, f32)> {
let covers = merged.entry((horizontal, at.to_bits())).or_insert_with(|| {
let k = key(at);
let mut covers: Vec<(f32, f32)> = (k - 1..=k + 1)
.filter_map(|k| rules.get(&(horizontal, k)))
.flatten()
.filter(|(c, _, _)| (c - at).abs() <= ON_EDGE)
.map(|&(_, s0, s1)| (s0, s1))
.collect();
covers.sort_by(|p, q| p.0.total_cmp(&q.0));
let mut spans: Vec<(f32, f32)> = Vec::with_capacity(covers.len());
for (c0, c1) in covers {
match spans.last_mut() {
Some(last) if c0 <= last.1 + ON_EDGE => last.1 = last.1.max(c1),
_ => spans.push((c0, c1)),
}
}
spans
});
let mut out = Vec::new();
let mut from = a;
for &(c0, c1) in &covers[covers.partition_point(|s| s.1 < a)..] {
if c0 > from + ON_EDGE {
out.push((from, c0.min(b)));
}
from = from.max(c1);
if from >= b {
break;
}
}
if from + ON_EDGE < b {
out.push((from, b));
}
out
};
let mut segs = Vec::new();
for r in gridline_cells(page, all, editing) {
let (l, t, rt, bt) = (r.x, r.y, r.x + r.w, r.y + r.h);
for y in [t, bt] {
segs.extend(uncovered(true, y, l, rt).into_iter().map(|(a, b)| (Point::new(a, y), Point::new(b, y))));
}
for x in [l, rt] {
segs.extend(uncovered(false, x, t, bt).into_iter().map(|(a, b)| (Point::new(x, a), Point::new(x, b))));
}
}
segs
}
/// The drawing grid's spacing in points at a screen scale: the document's spacing (`w:drawingGrid*Spacing`;
/// ECMA-376's 1/8 inch when it doesn't say), doubled until the lines are at least
/// [`DRAWING_GRID_MIN_PX`] apart on screen.
pub(super) fn drawing_grid_step(spacing: f32, scale: f32) -> f32 {
let mut step = if spacing.is_finite() && spacing > 0.0 { spacing } else { wordcraft_doc::DEFAULT_GRID };
if !(scale.is_finite() && scale > 0.0) {
return step;
}
for _ in 0..16 {
if step * scale >= DRAWING_GRID_MIN_PX {
break;
}
step *= 2.0;
}
step
}
/// Draw the document canvas in the space `ui` has left, one frame: the pages, caret, selection
/// and rulers, with the mouse editing and the pointer shape over them.
/// The layout the page shows: the document's own, or with the table Insert › Table's grid is
/// hovering over (#3931). The preview is laid out on a copy, so the document and its undo history
/// change only when a square is clicked.
pub(super) fn shown_layout(app: &mut WordApp) -> std::sync::Arc<DocLayout> {
let table = app.canvas.table_preview.take().map(|(rows, cols)| ("insert.table".to_string(), json!({"rows": rows, "cols": cols})));
let command = app.canvas.command_preview.take();
app.canvas.command_previewed = command.clone().filter(|_| table.is_none());
let Some((id, params)) = table.or(command) else {
app.canvas.table_preview_layout = None;
return app.session.layout();
};
// The caret can move, or the view change, with the grid still hovered: the table then goes
// somewhere else, or the page is laid out to another width.
let key = ((id.clone(), params.clone(), app.session.document_id(), app.session.rev(), app.session.sel.clone()), app.session.layout());
if let Some((k, _, _, l)) = &app.canvas.table_preview_layout
&& k.0 == key.0
&& std::sync::Arc::ptr_eq(&k.1, &key.1)
{
return l.clone();
}
match app.session.preview_layout(&id, ¶ms) {
Some((doc, sel, l)) => {
app.canvas.table_preview_layout = Some((key, doc, sel, l.clone()));
l
}
None => {
app.canvas.table_preview_layout = None;
app.session.layout()
}
}
}
/// The document the pages of [`shown_layout`] are drawn from: the previewed copy while the page
/// shows Insert › Table's preview, whose paragraph paths are the layout's (#3931).
pub(crate) fn page_doc(app: &WordApp) -> &wordcraft_doc::Document {
app.canvas.table_preview_layout.as_ref().map_or(&app.session.doc, |(_, doc, _, _)| doc)
}
/// The previewed copy's selection while the page shows Insert › Table's preview: the caret and
/// selection are drawn from it, as the document's own name other places in the preview's layout.
pub(crate) fn preview_sel(app: &WordApp) -> Option<&wordcraft_engine::Selection> {
app.canvas.table_preview_layout.as_ref().map(|(_, _, sel, _)| sel)
}
/// Whether the pages are drawn dark: View › Switch Modes, or in Read Mode the Page color's
/// Inverse (Switch Modes is ignored there). Drawing over the pages (ink, drag previews) follows it.
pub(crate) fn dark_page(app: &WordApp) -> bool {
use wordcraft_engine::cmd::view::ReadPageColor;
let v = &app.session.view;
if v.read_mode { v.read_page_color == ReadPageColor::Inverse } else { v.dark_mode }
}
/// Render options for this view's page rasters: marks, markup, dark page, header/body dimming.
pub(super) fn page_render_options(app: &WordApp, dim_body: bool) -> wordcraft_render::RenderOptions {
let mut opts = screen_render_options();
opts.display.marks = app.session.view.marks;
opts.display.always = app.session.prefs.marks;
opts.display.placeholders = true;
opts.display.markup = app.session.view.show_markup;
// Ink Replay draws the ink itself, stroke by stroke, over pages without it.
opts.display.hide_ink = app.session.view.hide_ink || app.session.view.draw.replay;
opts.display.revisions = app.session.prefs.markup.clone();
opts.dark = dark_page(app);
opts.dark_paper = wordcraft_render::DARK_PAPER;
// A screen tint (View › Paper color) paints the page, unless the page is drawn dark.
if !opts.dark {
opts.paper = app.session.prefs.paper_color.color();
}
// In Read Mode the Page color sets the paper: Sepia and Inverse as before, None the
// selected screen tint (white without one).
if app.session.view.read_mode {
use wordcraft_engine::cmd::view::ReadPageColor;
opts.read_paper = Some(match app.session.view.read_page_color {
ReadPageColor::None => app.session.prefs.paper_color.color(),
ReadPageColor::Sepia => wordcraft_render::SEPIA_PAPER,
ReadPageColor::Inverse => wordcraft_doc::props::Rgb::WHITE,
});
}
opts.display.dim_header = !dim_body;
opts.display.dim_body = dim_body;
opts
}
/// Render options for page rasters shown on screen, so a page looks as text does in the
/// platform's other apps (exports never change): on macOS, text is darkened the way the system
/// draws it; on Linux and the BSDs it is hinted lightly, as FreeType's `hintslight` draws it
/// there (not darkened: hinted text already has FreeType's weight, and darkening made it
/// look semi-bold).
pub(crate) fn screen_render_options() -> wordcraft_render::RenderOptions {
wordcraft_render::RenderOptions {
text_darkening: cfg!(target_os = "macos"),
hinting: cfg!(all(unix, not(target_os = "macos"))),
..Default::default()
}
}
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.