Files
Hector Villarreal aef22858a9 Select a table by rows when a drag crosses its columns (#3669)
## What this changes

Fixes #3850.

Partly addresses #3682: drags within one column of its two-column page now select that column's text (the tester's harness measured 3/9 → 7/9 on `cols.pdf`). Drags from one column into the next still follow reading order, as on `main`; they need column-correct reading order (#3676).

Selecting text in a table selected the wrong things. A table reads column by column, so a plain drag along one row, or down and across a few rows, took the rest of the first column and the top of the next ones between its ends. On some rows the highlight jumped to the column headers and half the table. Copy gave the cells out of order. Preview selects these by rows, and this makes PdfCraft do the same.

Rebased on `main` after the module split (#4889): the row selection is in `crates/render/src/text.rs`, the padded-cell join and barcode rows in `text/order.rs` and `text/layout.rs`, the drag's pointer end in `crates/ui-egui/src/canvas/selection.rs` and `canvas.rs`.

- **Visual rows** (`PageText::visual_between`, used by `Selection::rects` and `Selection::text`). The drag selects by rows when reading order between its ends would not follow them: the rest of the first row, the rows between, and the start of the last. Copy gives the cells tab-separated, as Column select does. Rows are used when either of these holds:
  - Reading order strays above or below the rows dragged over.
  - The drag ends in another column. That means across a gutter that no text of those rows crosses (checked a few lines above and below as well, so a justified line's wide word gap does not count), or with the pointer past the end of both lines.
- **Limits on the rows.** Rows never take lines left of everywhere the drag has been, and they stay in the column when the drag does. A drag in the right column of side-by-side text that ends on a hanging list marker does not pull in the left column. Running text keeps reading order whenever it covers the same glyphs, and so does a column of running text beside a sidebar. A drag down one article or table column keeps reading order too. A line's extent for these limits is its ink: spaces padding it out don't count.
- **Pointer position.** `Span::Run` records where the drag's pointer ended (`head_x`). It can lie well past the nearest glyph, as in the empty end of a table row. Select all, a clicked word, line or page, and four-click page selection keep reading order.
- **Hit testing.** `PageText::nearest` still takes the glyph whose em box holds the point first (#3693). Failing that, it prefers the row level with the pointer, so past the end of a short row a longer row just below no longer captures the drag. Between rows, the old distance rule still applies.
- **Padded cells.** Report generators pad each cell of a row with trailing spaces. When a cell's padding stops short of the next cell (more than the 3-height continuation gap), the next cell on its baseline now joins the row, within 8 line heights (`PADDED_FIELD`, `PADDED_REACH`). Without this, the row's last cells were read after the whole table, in selection, copy and `text_extract` alike.
- **Barcodes drawn with a font** (new since the last review). Mexican CFDI invoices and receipts print their QR or Aztec code with a barcode font: rows of glyphs stacked flush, 5 pt from the seal's text and on nearly the same baselines. Each code row joined the seal line beside it, so the seal read interleaved with the code, some seal lines came after the whole code, and a drag down the seal jumped through it. Rows of at least 8 glyphs, 4 or more stacked flush with one glyph count and the same edges (`barcode_rows`), now join no other text and read after the page's text. A point beside the code is not taken by the code row level with it.

## How you verified it

- [x] `cargo fmt --all --check`
- [x] `cargo clippy --workspace --all-targets --locked -- -D warnings`
- [x] tests pass on the crates I changed, and on the crates that use text extraction:

  | Crate or suite | Passed |
  |---|---|
  | `pdfcraft-render` (lib + integration) | 476 + 64 |
  | `pdfcraft-ui-egui --lib` | 696 |
  | `pdfcraft-ui-egui --test it` (`column_select`, `text_select`, `drag_selects`, `selection_works`) | 33 |
  | `pdfcraft-automation` | 359 |
  | `pdfcraft-engine` | 442 |
  | `pdfcraft-export` | 43 |

- [x] `cargo xtask layers`, `cargo xtask assets`, `cargo check -p pdfcraft-render --target wasm32-unknown-unknown`, `cargo xtask parity`

**Tests.** I reverted each fix and watched these fail:

- `column_select.rs::a_plain_drag_along_one_table_row_selects_only_that_row` (UI, select tool and highlighter). Before the fix it got `"Apple\nPear\nQty\n12"` instead of `"Apple\t12"`.
- `column_select.rs::a_drag_ending_between_the_columns_selects_the_rows` (UI). Without `head_x` it got `"Name\nApple\nPear"`.
- `column_select.rs::a_drag_down_text_beside_a_barcode_selects_only_the_text` (UI). Without the barcode rows it got `"ABCDEFGHIJKL one two three\nFGHIJKLMNOPQ\n…"`.
- `text/tests.rs::a_barcode_drawn_with_a_font_reads_apart_from_the_text_beside_it`
- `text/tests.rs::a_point_beside_a_barcode_takes_the_text_not_the_code_row`
- `text/tests.rs::a_point_level_with_a_row_takes_that_rows_nearest_glyph`
- `text/tests.rs::a_drag_in_the_right_column_takes_nothing_from_the_left`

Also new in `text/tests.rs`: `a_drag_along_one_table_row_selects_that_row`, `a_drag_over_table_rows_selects_those_rows`, `a_drag_that_reading_order_already_covers_keeps_it`, `a_pointer_ending_beside_the_column_takes_the_rows`, `a_cell_padded_with_spaces_joins_the_next_cell_of_its_row`, `a_justified_gap_is_not_a_gutter`, and the running-text, sidebar, heading and vertical-text cases from earlier review rounds. In `column_select.rs`: double-click drags, select all and four-click page selection on uneven columns.

All fixtures are synthetic.

**Corpus.** Before the rebase, text extraction of the pinned pdf.js corpus was byte-identical with and without this PR. The barcode change leaves it identical too: the plain text of the first 60 pages of each of its 989 PDFs (1,525 pages) is the same with and without it.

**Real-world files** (private, not attached):

- **Text extraction:** on a personal folder of PDFs (bank and hotel reports, payslips, policies, contracts, slide decks), the only files that differed from `main` before the rebase were bank statements whose padded rows now keep their amounts. The barcode change alters one page across 105 files: a statement's CFDI page, whose seal now reads in order.
- **Simulated drags:** about 53,700 random drags across those files. Selection takes at most about 145 µs per frame.
- **Two-column contract:** on a bilingual two-column contract, 2,649 drags kept inside one column leak into the other column less often than before (1,224 vs 1,591). In no file does the new code leak a two-column drag where the old one did not, except across table rows, where rows running across the page is intended.

## Never-crash

- [x] No new `unwrap`/`expect`/`panic!`/`unreachable!`/`todo!` outside tests
- [x] No indexing with input-derived positions in the new code (`get`). Allocations are bounded by the page's glyphs, and `side_by_side` compares at most `SIDE_BY_SIDE_LINES` lines. Barcode rows are found with one hash map over the page's rows. NaN boxes rank last in `nearest` (`total_cmp`) and are never barcode rows. No recursion.
- [x] No `unsafe`
- [ ] Any crash this fixes has a small synthetic regression test (n/a, no crash)

## Provenance

- [x] No asset from an Adobe product, and no Adobe icon recreated, traced or imitated
- [x] No font files committed here
- [x] No GPL/AGPL code copied in
- [x] Behaviour comes from black-box observation (Preview's selection on the same files), not from reading another implementation's source
- [x] No new assets

## Security

- [x] `--root` confinement untouched
- [x] MCP and the UI control channel untouched
- [x] No new outbound network access

## Parity and reach

- [x] `parity/acrobat-features.toml`: `view.text-select` gains the new evidence and a note. Selection across pages is still missing, as before.
- [x] Reachable headlessly: the padded-cell join and barcode rows change `text_extract` too. Visual-row selection is a pointer interaction, like the rest of plain drag selection.
- [x] `ROADMAP.md` progress log line

## Anything a reviewer should look at first

1. **A deliberate behaviour change.** `alt_drag_selects_only_the_text_inside_the_rectangle` asserted that a plain drag from "Name" to "12" selects in reading order: `"Name\nApple\nPear\nQty\n12"`. It now selects the two rows dragged over, `"Name\tQty\nApple\t12"`, and I changed the assertion. Reading order itself is unchanged (`a_column_selection_takes_one_table_column` still asserts it), and so is a drag down one column.
2. **The gutter test is a heuristic.** "Another column" means a vertical strip at least one line height wide that no text in the dragged rows, or 4 line heights around them, crosses. That catches table columns and side-by-side text, and ignores justified word gaps in practice. Thin columns with ragged edges may still fool it.
3. **The padded-cell join changes reading order.** It applies only to a segment whose box runs on at least 2 line heights of trailing spaces past its last visible glyph, and only towards a cell on the same baseline within 8 line heights.
4. **Barcode rows change reading order.** A stack of 4+ flush rows of 8+ glyphs, each with the same glyph count, height and edges, reads after the page's text. Text set solid still has lines of different lengths and counts; a hex dump set solid in a monospaced font would also match, and would then read last.
5. **Overlap with #2431** (narrow article gutters, #2387). The two PRs touch different code paths and should rebase cleanly.

<!-- This is an auto-generated comment: release notes by coderabbit.ai -->

## Summary by CodeRabbit

* **New Features**
  * Text drags across table-like layouts now select cells by visual row, with copied cells separated by tabs. Multi-click and Shift-click selections can also follow visual rows where applicable; select-all and other non-row selections retain reading order.
  * Text selection and pointer placement work more accurately around columns, gutters, and barcode-like text, reducing unintended selection of nearby content. Barcode text is kept separate from adjacent text.
* **Documentation**
  * Updated feature coverage and progress notes to reflect text-selection behavior and regression testing.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
2026-11-15 12:11:23 +01:00

358 lines
16 KiB
Rust
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! Issue #740: column select, as in Acrobat. Alt-drag (Option-drag on macOS) with the Select tool,
//! or a plain drag with Edit ▸ Column select, selects only the text inside the rectangle drawn.
use egui::{Event, Modifiers, PointerButton, Pos2, vec2};
use egui_kittest::Harness;
use pdfcraft_ui_egui::PdfCraftApp;
/// One 300×200 page with a three-row table, "Name Qty / Apple 12 / Pear 7". Its columns sit far
/// enough apart that reading order takes one column, then the other: glyphs 0–3 "Name", 4–8
/// "Apple", 9–12 "Pear", 13–15 "Qty", 16–17 "12", 18 "7".
fn table() -> Vec<u8> {
let content =
"BT /F1 14 Tf 20 150 Td (Name) Tj 130 0 Td (Qty) Tj -130 -24 Td (Apple) Tj 130 0 Td (12) Tj -130 -24 Td (Pear) Tj 130 0 Td (7) Tj ET";
format!(
"%PDF-1.7
1 0 obj << /Type /Catalog /Pages 2 0 R >> endobj
2 0 obj << /Type /Pages /Kids [3 0 R] /Count 1 >> endobj
3 0 obj << /Type /Page /Parent 2 0 R /MediaBox [0 0 300 200] /Contents 4 0 R /Resources << /Font << /F1 5 0 R >> >> >> endobj
4 0 obj << /Length {} >> stream
{content}
endstream endobj
5 0 obj << /Type /Font /Subtype /Type1 /BaseFont /Helvetica >> endobj
trailer << /Root 1 0 R >>
%%EOF",
content.len()
)
.into_bytes()
}
fn harness(setup: impl FnOnce(&mut PdfCraftApp) + 'static) -> Harness<'static, PdfCraftApp> {
let mut h = Harness::builder().with_size(egui::vec2(1400.0, 900.0)).with_step_dt(1.0 / 60.0).build_eframe(move |_cc| {
let mut app = PdfCraftApp::new();
app.set_option("language", "en").unwrap();
app.open_bytes("table.pdf", None, table()).expect("opens");
app.set_option("left", "closed").unwrap();
app.set_option("author", "Tester").unwrap();
setup(&mut app);
app
});
// Wait for the text layer itself (#1277): under load the first render takes longer than a
// fixed second, and nothing may be pending yet before the text layer is asked for.
crate::support::wait_until(&mut h, "the page's text layer", |app| app.views[0].glyph_screen_pos(0, 0).is_some() && !app.render_pending());
h
}
fn glyph(h: &Harness<'static, PdfCraftApp>, g: usize) -> Pos2 {
h.state().views[0].glyph_screen_pos(0, g).expect("glyph on screen")
}
fn text(h: &Harness<'static, PdfCraftApp>) -> Option<String> {
h.state().views[0].selected_text()
}
/// Press at `from`, move to `to` and release there, with `modifiers` held throughout.
fn drag(h: &mut Harness<'static, PdfCraftApp>, from: Pos2, to: Pos2, modifiers: Modifiers) {
h.event(Event::ModifiersChanged(modifiers));
h.hover_at(from);
h.run_steps(1);
h.event(Event::PointerButton { pos: from, button: PointerButton::Primary, pressed: true, modifiers });
h.run_steps(1);
for k in 1..=4 {
h.hover_at(from + (to - from) * (k as f32 / 4.0));
h.run_steps(1);
}
h.event(Event::PointerButton { pos: to, button: PointerButton::Primary, pressed: false, modifiers });
h.run_steps(1);
h.event(Event::ModifiersChanged(Modifiers::NONE));
h.run_steps(1);
}
/// Below-right of the top two rows: past the "y" of "Qty" (the wider cell), level with "12".
fn below_right_of_row_two(h: &Harness<'static, PdfCraftApp>) -> Pos2 {
egui::pos2(glyph(h, 15).x.max(glyph(h, 17).x) + 12.0, glyph(h, 17).y + 8.0)
}
/// From above-left of "Name" to below-right of "12": the top two rows of both columns.
fn top_two_rows(h: &Harness<'static, PdfCraftApp>) -> (Pos2, Pos2) {
(glyph(h, 0) - vec2(12.0, 12.0), below_right_of_row_two(h))
}
#[test]
fn alt_drag_selects_only_the_text_inside_the_rectangle() {
let mut h = harness(|_| {});
let (from, to) = top_two_rows(&h);
// A plain drag selects the rows it covers. Reading order, column by column, would take "Pear"
// from the row below on its way from "Name" to "12".
drag(&mut h, from, to, Modifiers::NONE);
assert_eq!(text(&h).as_deref(), Some("Name\tQty\nApple\t12"));
h.run_steps(60);
// Alt (Option on macOS) at the start of the drag: only the rectangle, row by row.
drag(&mut h, from, to, Modifiers::ALT);
assert_eq!(text(&h).as_deref(), Some("Name\tQty\nApple\t12"));
// One column of numbers, which is what the issue asked for.
h.run_steps(60);
let (from, to) = (glyph(&h, 13) - vec2(8.0, 12.0), egui::pos2(glyph(&h, 15).x + 12.0, glyph(&h, 18).y + 12.0));
drag(&mut h, from, to, Modifiers::ALT);
assert_eq!(text(&h).as_deref(), Some("Qty\n12\n7"));
}
#[test]
fn the_column_select_tool_needs_no_modifier() {
let mut h = harness(|app| assert!(app.execute("edit.column_select")));
assert_eq!(h.state().quick_tool, pdfcraft_ui_egui::QuickTool::ColumnSelect);
let (from, to) = top_two_rows(&h);
drag(&mut h, from, to, Modifiers::NONE);
assert_eq!(text(&h).as_deref(), Some("Name\tQty\nApple\t12"));
// A rectangle around no text selects nothing.
h.run_steps(60);
let below = glyph(&h, 12) + vec2(0.0, 60.0);
drag(&mut h, below, below + vec2(60.0, 30.0), Modifiers::NONE);
assert_eq!(text(&h), None);
}
/// ⇧-click extends a reading-order selection; a column selection has no anchor glyph, so a
/// ⇧-click clears it like a plain click.
#[test]
fn shift_click_clears_a_column_selection() {
let mut h = harness(|_| {});
let (from, to) = top_two_rows(&h);
drag(&mut h, from, to, Modifiers::ALT);
assert!(text(&h).is_some());
h.run_steps(60);
let at = glyph(&h, 10);
h.event(Event::ModifiersChanged(Modifiers::SHIFT));
h.hover_at(at);
h.run_steps(1);
for pressed in [true, false] {
h.event(Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Modifiers::SHIFT });
}
h.run_steps(1);
h.event(Event::ModifiersChanged(Modifiers::NONE));
h.run_steps(1);
assert_eq!(text(&h), None);
}
/// Alt-drag with the highlighter marks only the cells inside the rectangle: one quad per piece
/// of a line. The drag starts on text, since off text the highlighter draws an area highlight.
#[test]
fn alt_drag_with_the_highlighter_marks_only_the_column() {
let mut h = harness(|app| assert!(app.execute("comment.highlight")));
// Just above-left of the centre of "N", still on the glyph.
let (from, to) = (glyph(&h, 0) - vec2(2.0, 2.0), below_right_of_row_two(&h));
drag(&mut h, from, to, Modifiers::ALT);
h.run_steps(3);
let app = h.state();
let doc = app.session.get(app.views[0].id).unwrap();
let marks: Vec<(&str, usize)> = doc.info.annotations.iter().map(|a| (a.subtype.as_str(), a.quads.len())).collect();
assert_eq!(marks, [("Highlight", 4)], "Name, Qty, Apple and 12, each its own quad");
}
/// A column's rows and tab-separated cells are not paragraphs, so Copy puts the plain text on
/// the clipboard and no HTML, even where the clipboard would take it.
#[test]
fn a_column_selection_copies_plain_text_only() {
let offered = std::sync::Arc::new(std::sync::Mutex::new(0usize));
let seen = offered.clone();
let mut h = harness(move |app| {
app.system_clipboard = true;
app.html_clipboard_override = Some(Box::new(move |_, _| {
*seen.lock().unwrap() += 1;
true
}));
});
let (from, to) = top_two_rows(&h);
drag(&mut h, from, to, Modifiers::ALT);
assert!(h.state_mut().execute("edit.copy"));
h.step();
assert_eq!(*offered.lock().unwrap(), 0, "no HTML for a column selection");
let copied = h.output().platform_output.commands.iter().any(|c| matches!(c, egui::OutputCommand::CopyText(t) if t == "Name\tQty\nApple\t12"));
assert!(copied, "the plain text goes out the usual way");
}
/// A plain drag along one row of a table that reads column by column selects that row, as
/// Preview does, not the rest of the first column and the top of the second between its ends.
/// The highlighter marks the same cells.
#[test]
fn a_plain_drag_along_one_table_row_selects_only_that_row() {
let mut h = harness(|_| {});
// From just left of "Apple" to past "12", level with both.
let (from, to) = (glyph(&h, 4) - vec2(4.0, 0.0), glyph(&h, 17) + vec2(12.0, 0.0));
for (a, b) in [(from, to), (to, from)] {
h.key_press(egui::Key::Escape);
h.run_steps(60);
drag(&mut h, a, b, Modifiers::NONE);
assert_eq!(text(&h).as_deref(), Some("Apple\t12"));
}
let mut h = harness(|app| assert!(app.execute("comment.highlight")));
// The highlighter starts on text: the centre of "A".
let (from, to) = (glyph(&h, 4), glyph(&h, 17) + vec2(12.0, 0.0));
drag(&mut h, from, to, Modifiers::NONE);
h.run_steps(3);
let app = h.state();
let doc = app.session.get(app.views[0].id).unwrap();
let marks: Vec<(&str, usize)> = doc.info.annotations.iter().map(|a| (a.subtype.as_str(), a.quads.len())).collect();
assert_eq!(marks, [("Highlight", 2)], "Apple and 12, each its own quad");
}
/// A drag down from "Name" that ends in the gap between the columns, level with "Pear", crosses
/// into the rows: the nearest glyph is still in the first column, but the pointer is not.
#[test]
fn a_drag_ending_between_the_columns_selects_the_rows() {
let mut h = harness(|_| {});
let (from, pear) = (glyph(&h, 0) - vec2(4.0, 0.0), glyph(&h, 12));
// A little right of "Pear", well short of "7".
let gap = pear + vec2((glyph(&h, 18).x - pear.x) / 4.0, 0.0);
drag(&mut h, from, gap, Modifiers::NONE);
assert_eq!(text(&h).as_deref(), Some("Name\tQty\nApple\t12\nPear"));
// Over the first column, the drag stays in it.
h.key_press(egui::Key::Escape);
h.run_steps(60);
drag(&mut h, from, pear, Modifiers::NONE);
assert_eq!(text(&h).as_deref(), Some("Name\nApple\nPear"));
}
/// Two article columns, the right one a line shorter: its last glyph, the end of reading order,
/// sits above the left column's last line.
fn uneven_columns() -> Vec<u8> {
let content = "BT /F1 14 Tf \
1 0 0 1 20 250 Tm (Left first line.) Tj 1 0 0 1 220 250 Tm (Right first line.) Tj \
1 0 0 1 20 225 Tm (Left other line.) Tj 1 0 0 1 220 225 Tm (Right final line.) Tj \
1 0 0 1 20 200 Tm (Left final line.) Tj ET";
format!(
"%PDF-1.7\n\
1 0 obj << /Type /Catalog /Pages 2 0 R >> endobj\n\
2 0 obj << /Type /Pages /Kids [3 0 R] /Count 1 >> endobj\n\
3 0 obj << /Type /Page /Parent 2 0 R /MediaBox [0 0 400 300] /Contents 4 0 R /Resources << /Font << /F1 5 0 R >> >> >> endobj\n\
4 0 obj << /Length {} >> stream\n{content}\nendstream endobj\n\
5 0 obj << /Type /Font /Subtype /Type1 /BaseFont /Courier >> endobj\n\
trailer << /Root 1 0 R >>\n%%EOF",
content.len()
)
.into_bytes()
}
/// Select all takes the page's text in reading order, whole: it has no pointer, so the rows a
/// drag would take don't apply, though its last glyph is not the lowest.
#[test]
fn select_all_keeps_every_line_of_uneven_columns() {
let mut h = uneven_harness();
assert!(h.state_mut().views[0].select_all());
h.run_steps(1);
assert_eq!(text(&h).as_deref(), Some(UNEVEN_PAGE_TEXT));
}
/// Four clicks select the page, and a pointer that moves on a little after the fourth press
/// keeps it whole: the page unit has no rows to take.
#[test]
fn four_clicks_then_a_short_drag_keep_the_whole_page() {
let mut h = uneven_harness();
let at = glyph(&h, 2);
for _ in 0..3 {
for pressed in [true, false] {
h.hover_at(at);
h.event(Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE });
h.run_steps(1);
}
}
drag(&mut h, at, at + vec2(30.0, 8.0), Modifiers::NONE);
assert_eq!(text(&h).as_deref(), Some(UNEVEN_PAGE_TEXT));
}
fn uneven_harness() -> Harness<'static, PdfCraftApp> {
opened("uneven.pdf", uneven_columns())
}
/// A harness with the one-page PDF `bytes` open, its text layer ready.
fn opened(name: &'static str, bytes: Vec<u8>) -> Harness<'static, PdfCraftApp> {
let mut h = Harness::builder().with_size(egui::vec2(1400.0, 900.0)).with_step_dt(1.0 / 60.0).build_eframe(move |_cc| {
let mut app = PdfCraftApp::new();
app.set_option("language", "en").unwrap();
app.open_bytes(name, None, bytes).expect("opens");
app
});
crate::support::wait_until(&mut h, "the page's text layer", |app| app.views[0].glyph_screen_pos(0, 0).is_some() && !app.render_pending());
h
}
const UNEVEN_PAGE_TEXT: &str = "Left first line.\nLeft other line.\nLeft final line.\nRight first line.\nRight final line.";
/// A drag after a double-click extends by whole words, and over a table it takes the rows as a
/// plain drag does: from "Name" down to "12", not reading order's detour through "Pear".
#[test]
fn a_double_click_drag_over_table_rows_selects_the_rows() {
let mut h = harness(|_| {});
let (name, two) = (glyph(&h, 1), glyph(&h, 17));
for pressed in [true, false] {
h.hover_at(name);
h.event(Event::PointerButton { pos: name, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE });
h.run_steps(1);
}
drag(&mut h, name, two, Modifiers::NONE);
assert_eq!(text(&h).as_deref(), Some("Name\tQty\nApple\t12"));
}
/// An invoice's seal beside its QR code, the code drawn with a font as on a Mexican CFDI: eight
/// rows of twelve 6 pt Courier glyphs stacked flush (6 pt apart), and five 8 pt lines 5 pt to their
/// right, every other one on a code row's baseline. The seal reads first: glyphs 0–12 "one two
/// three", 13–25 "four five six", 26–36 "seven eight", 37–44 "nine ten", 45–57 "eleven twelve".
fn barcode_beside_seal() -> Vec<u8> {
let rows: String = BARCODE_ROWS.iter().map(|row| format!("({row}) Tj T* ")).collect();
let seal: String = SEAL.iter().map(|line| format!("({line}) Tj T* ")).collect();
let content = format!("BT /F1 6 Tf 6 TL 20 250 Td {rows}ET BT /F1 8 Tf 9 TL 68.2 250 Td {seal}ET");
format!(
"%PDF-1.7\n\
1 0 obj << /Type /Catalog /Pages 2 0 R >> endobj\n\
2 0 obj << /Type /Pages /Kids [3 0 R] /Count 1 >> endobj\n\
3 0 obj << /Type /Page /Parent 2 0 R /MediaBox [0 0 300 300] /Contents 4 0 R /Resources << /Font << /F1 5 0 R >> >> >> endobj\n\
4 0 obj << /Length {} >> stream\n{content}\nendstream endobj\n\
5 0 obj << /Type /Font /Subtype /Type1 /BaseFont /Courier >> endobj\n\
trailer << /Root 1 0 R >>\n%%EOF",
content.len()
)
.into_bytes()
}
const BARCODE_ROWS: [&str; 8] =
["ABCDEFGHIJKL", "FGHIJKLMNOPQ", "KLMNOPQRSTUV", "PQRSTUVWXYZA", "UVWXYZABCDEF", "ZABCDEFGHIJK", "EFGHIJKLMNOP", "JKLMNOPQRSTU"];
const SEAL: [&str; 5] = ["one two three", "four five six", "seven eight", "nine ten", "eleven twelve"];
/// A drag down the seal beside a QR code drawn with a font selects the seal's lines, in order,
/// and none of the code, whichever way it goes; the code's rows would otherwise join the seal's
/// lines level with them.
#[test]
fn a_drag_down_text_beside_a_barcode_selects_only_the_text() {
let mut h = opened("cfdi.pdf", barcode_beside_seal());
// From just left of "one" to past the end of "nine ten".
let (from, to) = (glyph(&h, 0) - vec2(4.0, 0.0), glyph(&h, 44) + vec2(12.0, 0.0));
for (a, b) in [(from, to), (to, from)] {
h.key_press(egui::Key::Escape);
h.run_steps(60);
drag(&mut h, a, b, Modifiers::NONE);
assert_eq!(text(&h).as_deref(), Some("one two three\nfour five six\nseven eight\nnine ten"));
}
// Select all: the seal, then the code.
assert!(h.state_mut().views[0].select_all());
h.run_steps(1);
assert_eq!(text(&h), Some([SEAL.join("\n"), BARCODE_ROWS.join("\n")].join("\n")));
}
/// A drag after a double-click on "Qty", left and down into "Apple", takes both words whole, as
/// rows: reading order has "Apple" first, but the rows start at the upper word. So does the drag
/// the other way, from "Apple" up into "Qty", and along one row, from "Name" into "Qty" and back.
#[test]
fn a_double_click_drag_back_across_the_columns_keeps_whole_words() {
for (from, to, copied) in [(14, 6, "Qty\nApple"), (6, 14, "Qty\nApple"), (1, 14, "Name\tQty"), (14, 1, "Name\tQty")] {
let mut h = harness(|_| {});
let (from, to) = (glyph(&h, from), glyph(&h, to));
for pressed in [true, false] {
h.hover_at(from);
h.event(Event::PointerButton { pos: from, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE });
h.run_steps(1);
}
drag(&mut h, from, to, Modifiers::NONE);
assert_eq!(text(&h).as_deref(), Some(copied));
}
}