Grcov report - paged

1

//! CSS Paged Media layout integration with integrated fragmentation

2

//!

3

//! This module provides functionality for laying out documents with pagination,

4

//! such as for PDF generation. It uses the new integrated architecture where:

5

//!

6

//! 1. `page_index` is assigned to nodes DURING layout based on Y position

7

//! 2. `generate_display_lists_paged()` creates per-page `DisplayLists` by filtering

8

//! 3. No post-hoc fragmentation is needed

9

//!

10

//! **Note**: Full CSS `@page` rule parsing is not yet implemented. The `FakePageConfig`

11

//! provides programmatic control over page decoration as a temporary solution.

12

13

use crate::solver3::layout_tree::LayoutNodeId;

14

use crate::debug_log;

15

use std::collections::BTreeMap;

16

17

use azul_core::{

18

    dom::{DomId, NodeId},

19

    geom::{LogicalPosition, LogicalRect, LogicalSize},

20

    hit_test::ScrollPosition,

21

    resources::RendererResources,

22

    selection::TextSelection,

23

    styled_dom::StyledDom,

24

};

25

use azul_css::LayoutDebugMessage;

26

27

use crate::{

28

    font_traits::{ParsedFontTrait, TextLayoutCache},

29

    paged::FragmentationContext,

30

    solver3::{

31

        cache::LayoutCache,

32

        display_list::DisplayList,

33

        pagination::FakePageConfig,

34

        LayoutContext, LayoutError, Result,

35

},

36

};

37

38

/// Layout a document with integrated pagination, returning one `DisplayList` per page.

39

///

40

/// +spec:positioning:a4936a - Absolutely positioned elements positioned relative to containing block ignoring page breaks

41

/// Layout is performed on a continuous document; pages are split afterward by Y position,

42

/// so absolutely positioned elements are positioned as if the document were continuous.

43

///

44

/// This function performs CSS Paged Media layout with fragmentation integrated

45

/// into the layout process itself, using the new architecture where:

46

///

47

/// 1. The `FragmentationContext` is passed to `layout_document` via `LayoutContext`

48

/// 2. Nodes get their `page_index` assigned during layout based on absolute Y position

49

/// 3. `DisplayLists` are generated per-page by filtering items based on page bounds

50

///

51

/// Uses default page header/footer configuration (page numbers in footer).

52

/// For custom headers/footers, use `layout_document_paged_with_config`.

53

///

54

/// # Arguments

55

/// * `fragmentation_context` - Controls page size and fragmentation behavior

56

/// * Other arguments same as `layout_document()`

57

///

58

/// # Returns

59

/// A vector of `DisplayLists`, one per page. Each `DisplayList` contains the

60

/// elements that fit on that page, with Y-coordinates relative to the page origin.

61

#[cfg(feature = "text_layout")]

62

/// # Errors

63

///

64

/// Returns a `LayoutError` if paged layout fails.

65

1

pub fn layout_document_paged<T, F>(

66

1

    cache: &mut LayoutCache,

67

1

    text_cache: &mut TextLayoutCache,

68

1

    fragmentation_context: FragmentationContext,

69

1

    new_dom: &StyledDom,

70

1

    viewport: LogicalRect,

71

1

    font_manager: &mut crate::font_traits::FontManager<T>,

72

1

    scroll_offsets: &BTreeMap<NodeId, ScrollPosition>,

73

1

    debug_messages: &mut Option<Vec<LayoutDebugMessage>>,

74

1

    gpu_value_cache: Option<&azul_core::gpu::GpuValueCache>,

75

1

    renderer_resources: &RendererResources,

76

1

    id_namespace: azul_core::resources::IdNamespace,

77

1

    dom_id: DomId,

78

1

    font_loader: F,

79

1

    image_cache: &azul_core::resources::ImageCache,

80

1

    get_system_time_fn: azul_core::task::GetSystemTimeCallback,

81

1

) -> Result<Vec<DisplayList>>

82

1

where

83

1

    T: ParsedFontTrait + Sync + 'static,

84

1

    F: Fn(

85

1

        std::sync::Arc<rust_fontconfig::FontBytes>,

86

1

        usize,

87

1

    ) -> std::result::Result<T, crate::text3::cache::LayoutError>,

88

89

    // Use default page config (page numbers in footer)

90

1

    let page_config = FakePageConfig::new().with_footer_page_numbers();

91

92

1

    layout_document_paged_with_config(

93

1

        cache,

94

1

        text_cache,

95

1

        fragmentation_context,

96

1

        new_dom,

97

1

        viewport,

98

1

        font_manager,

99

1

        scroll_offsets,

100

1

        debug_messages,

101

1

        gpu_value_cache,

102

1

        renderer_resources,

103

1

        id_namespace,

104

1

        dom_id,

105

1

        font_loader,

106

1

        page_config,

107

1

        image_cache,

108

1

        get_system_time_fn,

109

        false,

110

111

1

112

113

/// The full result of a paged layout: the analysis alongside the pages.

114

///

115

/// `pages[i].node_mapping` carries the per-item source `NodeId`s of page `i`

116

/// (paged hit-testing / diagnostics); `breaks` is the same analysis a

117

/// document editor gets from [`compute_document_pagination`] without

118

/// materializing any page.

119

#[derive(Debug)]

120

pub struct PagedLayoutResult {

121

    /// One display list per page.

122

    pub pages: Vec<DisplayList>,

123

    /// The break analysis the pages were sliced by (empty for continuous media).

124

    pub breaks: Vec<crate::solver3::page_breaks::PageBreakPosition>,

125

    /// Total document-space content height of the un-sliced document.

126

    pub total_content_height: f32,

127

128

129

/// Layout a document with integrated pagination and custom page configuration.

130

///

131

/// This function is the same as `layout_document_paged` but allows you to

132

/// specify custom headers and footers via `FakePageConfig`.

133

///

134

/// # Arguments

135

/// * `page_config` - Configuration for page headers/footers (see `FakePageConfig`)

136

/// * Other arguments same as `layout_document_paged()`

137

#[cfg(feature = "text_layout")]

138

// page_config is a small owned config struct passed once per paged-layout invocation by the

139

// dll PDF backend and the test suite; taking it by value keeps that one-shot API ergonomic.

140

#[allow(clippy::needless_pass_by_value)]

141

#[allow(clippy::too_many_arguments)]

142

/// # Errors

143

///

144

/// Returns a `LayoutError` if paged layout fails.

145

151

pub fn layout_document_paged_with_config<T, F>(

146

151

    cache: &mut LayoutCache,

147

151

    text_cache: &mut TextLayoutCache,

148

151

    fragmentation_context: FragmentationContext,

149

151

    new_dom: &StyledDom,

150

151

    viewport: LogicalRect,

151

    font_manager: &mut crate::font_traits::FontManager<T>,

152

151

    scroll_offsets: &BTreeMap<NodeId, ScrollPosition>,

153

151

    debug_messages: &mut Option<Vec<LayoutDebugMessage>>,

154

151

    gpu_value_cache: Option<&azul_core::gpu::GpuValueCache>,

155

151

    renderer_resources: &RendererResources,

156

151

    id_namespace: azul_core::resources::IdNamespace,

157

151

    dom_id: DomId,

158

151

    font_loader: F,

159

151

    page_config: FakePageConfig,

160

151

    image_cache: &azul_core::resources::ImageCache,

161

151

    get_system_time_fn: azul_core::task::GetSystemTimeCallback,

162

151

    print_timing: bool,

163

151

) -> Result<Vec<DisplayList>>

164

151

where

165

151

    T: ParsedFontTrait + Sync + 'static,

166

151

    F: Fn(

167

151

        std::sync::Arc<rust_fontconfig::FontBytes>,

168

151

        usize,

169

151

    ) -> std::result::Result<T, crate::text3::cache::LayoutError>,

170

171

    // Thin wrapper over the analysis-returning entry so printpdf 0.12.x

172

    // compiles unchanged; migrate to `layout_document_paged_v2` to get the

173

    // break analysis alongside the pages.

174

151

    layout_document_paged_v2(

175

151

        cache,

176

151

        text_cache,

177

151

        fragmentation_context,

178

151

        new_dom,

179

151

        viewport,

180

151

        font_manager,

181

151

        scroll_offsets,

182

151

        debug_messages,

183

151

        gpu_value_cache,

184

151

        renderer_resources,

185

151

        id_namespace,

186

151

        dom_id,

187

151

        font_loader,

188

151

        page_config,

189

151

        image_cache,

190

151

        get_system_time_fn,

191

151

        print_timing,

192

193

151

    .map(|r| r.pages)

194

151

195

196

/// [`layout_document_paged_with_config`], returning the break ANALYSIS

197

/// alongside the pages (the document-editor/printpdf-diagnostics upgrade).

198

#[cfg(feature = "text_layout")]

199

#[allow(clippy::too_many_arguments)]

200

/// # Errors

201

///

202

/// Returns a `LayoutError` if paged layout fails.

203

151

pub fn layout_document_paged_v2<T, F>(

204

151

    cache: &mut LayoutCache,

205

151

    text_cache: &mut TextLayoutCache,

206

151

    fragmentation_context: FragmentationContext,

207

151

    new_dom: &StyledDom,

208

151

    viewport: LogicalRect,

209

151

    font_manager: &mut crate::font_traits::FontManager<T>,

210

151

    scroll_offsets: &BTreeMap<NodeId, ScrollPosition>,

211

151

    debug_messages: &mut Option<Vec<LayoutDebugMessage>>,

212

151

    gpu_value_cache: Option<&azul_core::gpu::GpuValueCache>,

213

151

    renderer_resources: &RendererResources,

214

151

    id_namespace: azul_core::resources::IdNamespace,

215

151

    dom_id: DomId,

216

151

    font_loader: F,

217

151

    page_config: FakePageConfig,

218

151

    image_cache: &azul_core::resources::ImageCache,

219

151

    get_system_time_fn: azul_core::task::GetSystemTimeCallback,

220

151

    print_timing: bool,

221

151

) -> Result<PagedLayoutResult>

222

151

where

223

151

    T: ParsedFontTrait + Sync + 'static,

224

151

    F: Fn(

225

151

        std::sync::Arc<rust_fontconfig::FontBytes>,

226

151

        usize,

227

151

    ) -> std::result::Result<T, crate::text3::cache::LayoutError>,

228

229

151

    layout_document_paged_impl(

230

151

        cache, text_cache, fragmentation_context, new_dom, viewport, font_manager,

231

151

        scroll_offsets, debug_messages, gpu_value_cache, renderer_resources,

232

151

        id_namespace, dom_id, font_loader, page_config, image_cache,

233

151

        get_system_time_fn, print_timing, true,

234

235

151

236

237

#[cfg(feature = "text_layout")]

238

#[allow(clippy::needless_pass_by_value)]

239

#[allow(clippy::too_many_arguments)]

240

#[allow(clippy::too_many_lines)] // large but cohesive: single-purpose layout/render/parse routine (one branch per case)

241

184

fn layout_document_paged_impl<T, F>(

242

184

    cache: &mut LayoutCache,

243

184

    text_cache: &mut TextLayoutCache,

244

184

    mut fragmentation_context: FragmentationContext,

245

184

    new_dom: &StyledDom,

246

184

    viewport: LogicalRect,

247

184

    font_manager: &mut crate::font_traits::FontManager<T>,

248

184

    scroll_offsets: &BTreeMap<NodeId, ScrollPosition>,

249

184

    debug_messages: &mut Option<Vec<LayoutDebugMessage>>,

250

184

    gpu_value_cache: Option<&azul_core::gpu::GpuValueCache>,

251

184

    renderer_resources: &RendererResources,

252

184

    id_namespace: azul_core::resources::IdNamespace,

253

184

    dom_id: DomId,

254

184

    font_loader: F,

255

184

    page_config: FakePageConfig,

256

184

    image_cache: &azul_core::resources::ImageCache,

257

184

    get_system_time_fn: azul_core::task::GetSystemTimeCallback,

258

184

    print_timing: bool,

259

184

    materialize_pages: bool,

260

184

) -> Result<PagedLayoutResult>

261

184

where

262

184

    T: ParsedFontTrait + Sync + 'static,

263

184

    F: Fn(

264

184

        std::sync::Arc<rust_fontconfig::FontBytes>,

265

184

        usize,

266

184

    ) -> std::result::Result<T, crate::text3::cache::LayoutError>,

267

268

    use crate::solver3::display_list::{

269

        calculate_display_list_height, generate_display_list, paginate_display_list_with_breaks,

270

        SlicerConfig,

271

};

272

    use crate::solver3::page_breaks;

273

274

    // Font Resolution And Loading

275

276

        use crate::solver3::getters::{

277

            collect_and_resolve_font_chains_with_registration, collect_font_ids_from_chains,

278

            compute_fonts_to_load, load_fonts_from_disk,

279

};

280

281

        // SKIP THE RESOLVER when this DOM asks for the same font stacks the

282

        // manager already resolved. `LayoutWindow` has done this since the

283

        // beginning (window.rs, `font_requirements_unchanged`) via a rolling

284

        // hash of the compact cache's `prev_font_hashes`; the pagination

285

        // entry points did not — and worse, called the plain

286

        // `set_font_chain_cache`, which CLEARS the recorded signature, so

287

        // even a caller reusing one FontManager re-resolved a 160-family

288

        // chain on EVERY pagination (measured 8 ms/call, ~8% of a warm one).

289

184

        let font_stacks_sig = new_dom

290

184

            .css_property_cache

291

184

            .ptr

292

184

            .compact_cache

293

184

            .as_ref()

294

184

            .map(|cc| {

295

183

                let mut h: u64 = 0xcbf2_9ce4_8422_2325;

296

3491

                for &fh in &cc.prev_font_hashes {

297

3308

                    h = h.rotate_left(13) ^ fh;

298

3308

                    h = h.wrapping_mul(0x0100_0000_01b3);

299

3308

300

183

301

183

});

302

184

        let font_requirements_unchanged = font_stacks_sig.is_some()

303

183

            && font_stacks_sig == font_manager.last_resolved_font_stacks_sig

304

18

            && !font_manager.font_chain_cache.is_empty();

305

306

184

        if !font_requirements_unchanged {

307

167

            let _p = crate::probe::Probe::span("font_chain_resolve");

308

167

            let trace = std::env::var_os("AZ_PAGINATE_TRACE").is_some();

309

            // Clock reads are GATED ON `trace`, and use azul_core's clock rather

310

            // than std's, for two independent reasons:

311

//

312

            //   * `std::time::Instant::now()` PANICS on wasm32-unknown-unknown,

313

            //     and azul-layout is built for wasm with `text_layout` (which

314

            //     turns std on, so a `feature = "std"` gate would not save it).

315

            //   * `azul_core::task::Instant` is FFI-shaped: it owns a

316

            //     `ManuallyDrop<Box<StdInstant>>`, so every `now()` is a heap

317

            //     allocation. Taking one unconditionally on this path made

318

            //     `regenerate_layout` grow 1112 B/iter under resize stress and

319

            //     tripped the leak regression test — which is exactly what that

320

            //     test is for.

321

//

322

            // Tracing is off in every normal run, so this costs nothing there.

323

167

            let t0 = trace.then(azul_core::task::Instant::now);

324

167

            let platform = azul_css::system::Platform::current();

325

326

167

            let chains = collect_and_resolve_font_chains_with_registration(

327

167

                new_dom, &font_manager.fc_cache, font_manager, &platform,

328

);

329

167

            let t_resolve =

330

167

                t0.map(|t0| azul_core::task::Instant::now().duration_since(&t0));

331

332

167

            let required_fonts = collect_font_ids_from_chains(&chains);

333

167

            let already_loaded = font_manager.get_loaded_font_ids();

334

167

            let fonts_to_load = compute_fonts_to_load(&required_fonts, &already_loaded);

335

167

            if trace {

336

                eprintln!(

337

                    "[paginate] font_chain_resolve {t_resolve:?}: {} chain(s), {} font(s) \

338

                     required, {} already loaded, {} to load",

339

                    chains.chains.len(),

340

                    required_fonts.len(),

341

                    already_loaded.len(),

342

                    fonts_to_load.len(),

343

);

344

167

345

346

167

            if !fonts_to_load.is_empty() {

347

129

                let t1 = trace.then(azul_core::task::Instant::now);

348

129

                let load_result =

349

129

                    load_fonts_from_disk(&fonts_to_load, &font_manager.fc_cache, &font_loader);

350

129

                if trace {

351

                    eprintln!(

352

                        "[paginate] load_fonts_from_disk {:?}: {} loaded, {} failed",

353

                        t1.map(|t1| azul_core::task::Instant::now().duration_since(&t1)),

354

                        load_result.loaded.len(),

355

                        load_result.failed.len(),

356

);

357

129

358

359

129

                font_manager.insert_fonts(load_result.loaded);

360

145

                for (font_id, error) in &load_result.failed {

361

16

                    if let Some(msgs) = debug_messages {

362

16

                        msgs.push(LayoutDebugMessage::warning(format!(

363

16

                            "[FontLoading] Failed to load font {font_id:?}: {error}"

364

16

                        )));

365

16

366

367

38

368

167

            font_manager

369

167

                .set_font_chain_cache_with_sig(chains.into_fontconfig_chains(), font_stacks_sig);

370

17

371

372

373

    // Get page dimensions from fragmentation context

374

184

    let page_content_height = fragmentation_context.page_content_height();

375

376

    // Handle continuous media (no pagination)

377

184

    if !fragmentation_context.is_paged() {

378

1

        let _p = crate::probe::Probe::span("paged_layout_pass");

379

1

        compute_layout_with_fragmentation(

380

1

            cache,

381

1

            text_cache,

382

1

            &mut fragmentation_context,

383

1

            new_dom,

384

1

            viewport,

385

1

            font_manager,

386

1

            debug_messages,

387

1

            image_cache,

388

1

            get_system_time_fn,

389

1

            print_timing,

390

)?;

391

392

        // Generate display list from cached tree/positions

393

1

        let tree = cache.tree.as_ref().ok_or(LayoutError::InvalidTree)?;

394

1

        let mut counter_values = cache.counters.clone();

395

1

        let empty_text_selections: BTreeMap<DomId, TextSelection> = BTreeMap::new();

396

1

        let mut ctx = LayoutContext {

397

1

            reflowed_ifcs: std::collections::BTreeSet::new(),

398

1

            style_cache: Default::default(),

399

1

            scrollbar_style_cache: core::cell::RefCell::new(std::collections::HashMap::new()),

400

1

            styled_dom: new_dom,

401

1

            font_manager: &*font_manager,

402

1

            text_selections: &empty_text_selections,

403

1

            debug_messages,

404

1

            counters: &mut counter_values,

405

1

            viewport_size: viewport.size,

406

1

            fragmentation_context: Some(&mut fragmentation_context),

407

1

            cursor_is_visible: true,

408

1

            cursor_locations: Vec::new(),

409

1

            preedit_text: None,

410

1

            cache_map: std::mem::take(&mut cache.cache_map),

411

1

            image_cache,

412

1

            content_overlay: None,

413

1

            system_style: None,

414

1

            get_system_time_fn,

415

1

};

416

417

1

        let _p = crate::probe::Probe::span("paged_display_list");

418

1

        let display_list = generate_display_list(

419

1

            &mut ctx,

420

1

            tree,

421

1

            &cache.calculated_positions,

422

1

            scroll_offsets,

423

1

            &cache.scroll_ids,

424

1

            gpu_value_cache,

425

1

            renderer_resources,

426

1

            id_namespace,

427

1

            dom_id,

428

)?;

429

1

        cache.cache_map = std::mem::take(&mut ctx.cache_map);

430

1

        let total_content_height = calculate_display_list_height(&display_list);

431

1

        return Ok(PagedLayoutResult {

432

1

            pages: vec![display_list],

433

1

            breaks: Vec::new(),

434

1

            total_content_height,

435

1

});

436

183

437

438

    // Paged Layout

439

440

    // Perform layout with fragmentation context (layout only, no display list)

441

183

    let p_layout = crate::probe::Probe::span("paged_layout_pass");

442

183

    compute_layout_with_fragmentation(

443

183

        cache,

444

183

        text_cache,

445

183

        &mut fragmentation_context,

446

183

        new_dom,

447

183

        viewport,

448

183

        font_manager,

449

183

        debug_messages,

450

183

        image_cache,

451

183

        get_system_time_fn,

452

183

        print_timing,

453

)?;

454

455

    // Get the layout tree and positions

456

183

    let tree = cache.tree.as_ref().ok_or(LayoutError::InvalidTree)?;

457

183

    let calculated_positions = &cache.calculated_positions;

458

459

    // Debug: log page layout info

460

183

    if let Some(msgs) = debug_messages {

461

132

        msgs.push(LayoutDebugMessage::info(format!(

462

132

            "[PagedLayout] Page content height: {page_content_height}"

463

132

        )));

464

162

465

466

    // Use scroll IDs computed by compute_layout_with_fragmentation (stored in cache)

467

183

    let scroll_ids = &cache.scroll_ids;

468

469

    // Create temporary context for display list generation

470

183

    let mut counter_values = cache.counters.clone();

471

183

    let empty_text_selections: BTreeMap<DomId, TextSelection> = BTreeMap::new();

472

183

    let mut ctx = LayoutContext {

473

183

            reflowed_ifcs: std::collections::BTreeSet::new(),

474

183

        style_cache: Default::default(),

475

183

        scrollbar_style_cache: core::cell::RefCell::new(std::collections::HashMap::new()),

476

183

        styled_dom: new_dom,

477

183

        font_manager: &*font_manager,

478

183

        text_selections: &empty_text_selections,

479

183

        debug_messages,

480

183

        counters: &mut counter_values,

481

183

        viewport_size: viewport.size,

482

183

        fragmentation_context: Some(&mut fragmentation_context),

483

183

        cursor_is_visible: true, // Paged layout: cursor always visible

484

183

        cursor_locations: Vec::new(),   // Paged layout: no cursor

485

183

        preedit_text: None,

486

183

        cache_map: std::mem::take(&mut cache.cache_map),

487

183

        image_cache,

488

183

        content_overlay: None,

489

183

        system_style: None,

490

183

        get_system_time_fn,

491

183

};

492

493

    // NEW: Use the commitment-based pagination approach with CSS break properties

494

//

495

    // This treats pages as viewports into a single infinite canvas:

496

    // 1. Generate ONE complete display list on infinite vertical strip

497

    // 2. Analyze CSS break properties (break-before, break-after, break-inside)

498

    // 3. Calculate page boundaries based on break properties

499

    // 4. Slice content to page boundaries (items are NEVER shifted, only clipped)

500

    // 5. Headers and footers are injected per-page

501

//

502

    // Benefits over the old approach:

503

    // - No coordinate desynchronization between page_index and actual Y position

504

    // - Backgrounds render correctly (clipped, not torn/duplicated)

505

    // - Simple mental model: pages are just views into continuous content

506

    // - Headers/footers with page numbers are automatically generated

507

    // - CSS fragmentation properties are respected

508

509

    // Step 1: Generate ONE complete display list (infinite canvas)

510

183

    drop(p_layout);

511

183

    let _p_dl = crate::probe::Probe::span("paged_display_list");

512

183

    let full_display_list = generate_display_list(

513

183

        &mut ctx,

514

183

        tree,

515

183

        calculated_positions,

516

183

        scroll_offsets,

517

183

        scroll_ids,

518

183

        gpu_value_cache,

519

183

        renderer_resources,

520

183

        id_namespace,

521

183

        dom_id,

522

)?;

523

524

183

    if let Some(msgs) = ctx.debug_messages {

525

132

        msgs.push(LayoutDebugMessage::info(format!(

526

132

            "[PagedLayout] Generated master display list with {} items",

527

132

            full_display_list.items.len()

528

132

        )));

529

162

530

531

    // Step 2: Configure the slicer with page dimensions and headers/footers

532

183

    let page_width = viewport.size.width;

533

183

    let header_footer = page_config.to_header_footer_config();

534

535

183

    if let Some(msgs) = ctx.debug_messages {

536

132

        msgs.push(LayoutDebugMessage::info(format!(

537

132

            "[PagedLayout] Page config: header={}, footer={}, skip_first={}",

538

132

            header_footer.show_header, header_footer.show_footer, header_footer.skip_first_page

539

132

        )));

540

162

541

542

    // B3c: with repeat_table_headers on, capture every table's thead from

543

    // the master display list — the registration side the tracker lacked.

544

183

    let table_headers = if page_config.break_policy.repeat_table_headers {

545

        crate::solver3::pagination::collect_table_headers(&full_display_list, new_dom)

546

    } else {

547

183

        crate::solver3::pagination::TableHeaderTracker::default()

548

};

549

550

183

    let slicer_config = SlicerConfig {

551

183

        page_content_height,

552

183

        page_gap: 0.0,

553

183

        allow_clipping: true,

554

183

        header_footer,

555

183

        page_width,

556

183

        table_headers,

557

183

        break_policy: page_config.break_policy,

558

183

        page_sequence: page_config.page_sequence,

559

183

};

560

561

    // Step 3: Analyze the breaks, THEN paginate against them — the analysis

562

    // is part of the result (document editors consume it without the pages).

563

    // Break-awareness runs per `slicer_config.break_policy` (all-off default

564

    // = the plain interval algorithm).

565

183

    let break_input = page_breaks::PageBreakInput {

566

183

        display_list: &full_display_list,

567

183

        layout_tree: cache.tree.as_ref(),

568

183

        styled_dom: new_dom,

569

183

        table_headers: Some(&slicer_config.table_headers),

570

183

};

571

183

    let breaks = if let Some(sequence) = &slicer_config.page_sequence {

572

        // classic office suites model: every page's height from ITS setup.

573

3

        page_breaks::compute_page_breaks_with_sequence(

574

3

            &break_input,

575

3

            sequence,

576

3

            &slicer_config.break_policy,

577

578

    } else {

579

180

        let constraints = page_breaks::PageConstraints::from_slicer_config(&slicer_config);

580

180

        page_breaks::compute_page_breaks(&break_input, &constraints, &slicer_config.break_policy)

581

};

582

183

    let total_content_height = calculate_display_list_height(&full_display_list);

583

584

183

    let pages = if materialize_pages {

585

150

        paginate_display_list_with_breaks(

586

150

            full_display_list,

587

150

            &slicer_config,

588

150

            &breaks,

589

150

            renderer_resources,

590

)?

591

    } else {

592

        // Precalculation-only: the analysis IS the result; no page is sliced.

593

33

        Vec::new()

594

};

595

596

183

    if let Some(msgs) = ctx.debug_messages {

597

132

        msgs.push(LayoutDebugMessage::info(format!(

598

132

            "[PagedLayout] Paginated into {} pages with CSS break support",

599

132

            pages.len()

600

132

        )));

601

162

602

603

183

    cache.cache_map = std::mem::take(&mut ctx.cache_map);

604

605

183

    Ok(PagedLayoutResult {

606

183

        pages,

607

183

        breaks,

608

183

        total_content_height,

609

183

})

610

184

611

612

/// The PRECALCULATION-ONLY path (the document-editor requirement).

613

///

614

/// Full layout + display-list generation + break analysis, but NO per-page

615

/// display list is ever materialized. Pair with

616

/// [`crate::solver3::display_list::paginate_single_page`] to materialize

617

/// only visible pages, and [`crate::solver3::page_breaks::page_of_y`] to map

618

/// a node's Y to its page.

619

#[cfg(feature = "text_layout")]

620

#[allow(clippy::needless_pass_by_value)]

621

#[allow(clippy::too_many_arguments)]

622

/// # Errors

623

///

624

/// Returns a `LayoutError` if layout fails.

625

33

pub fn compute_document_pagination<T, F>(

626

33

    cache: &mut LayoutCache,

627

33

    text_cache: &mut TextLayoutCache,

628

33

    fragmentation_context: FragmentationContext,

629

33

    new_dom: &StyledDom,

630

33

    viewport: LogicalRect,

631

33

    font_manager: &mut crate::font_traits::FontManager<T>,

632

33

    scroll_offsets: &BTreeMap<NodeId, ScrollPosition>,

633

33

    debug_messages: &mut Option<Vec<LayoutDebugMessage>>,

634

33

    gpu_value_cache: Option<&azul_core::gpu::GpuValueCache>,

635

33

    renderer_resources: &RendererResources,

636

33

    id_namespace: azul_core::resources::IdNamespace,

637

33

    dom_id: DomId,

638

33

    font_loader: F,

639

33

    page_config: FakePageConfig,

640

33

    image_cache: &azul_core::resources::ImageCache,

641

33

    get_system_time_fn: azul_core::task::GetSystemTimeCallback,

642

33

) -> Result<crate::solver3::page_breaks::PaginationInfo>

643

33

where

644

33

    T: ParsedFontTrait + Sync + 'static,

645

33

    F: Fn(

646

33

        std::sync::Arc<rust_fontconfig::FontBytes>,

647

33

        usize,

648

33

    ) -> std::result::Result<T, crate::text3::cache::LayoutError>,

649

650

    use crate::solver3::page_breaks;

651

652

33

    let result = layout_document_paged_impl(

653

33

        cache,

654

33

        text_cache,

655

33

        fragmentation_context,

656

33

        new_dom,

657

33

        viewport,

658

33

        font_manager,

659

33

        scroll_offsets,

660

33

        debug_messages,

661

33

        gpu_value_cache,

662

33

        renderer_resources,

663

33

        id_namespace,

664

33

        dom_id,

665

33

        font_loader,

666

33

        page_config,

667

33

        image_cache,

668

33

        get_system_time_fn,

669

        false,

670

        false, // NO page is materialized — the acceptance criterion of this entry

671

)?;

672

33

    let page_count = page_breaks::page_spans(&result.breaks, result.total_content_height)

673

33

        .len()

674

33

        .max(1);

675

33

    Ok(page_breaks::PaginationInfo {

676

33

        page_count,

677

33

        breaks: result.breaks,

678

33

        total_content_height: result.total_content_height,

679

33

})

680

33

681

682

/// Internal helper: Perform layout with a fragmentation context (layout only, no display list)

683

///

684

/// The tree, positions, and scroll IDs are stored in `cache`. To generate a display list,

685

/// call `generate_display_list` separately using the tree/positions from the cache.

686

#[cfg(feature = "text_layout")]

687

#[allow(clippy::too_many_lines)] // large but cohesive: single-purpose layout/render/parse routine (one branch per case)

688

210

fn compute_layout_with_fragmentation<T: ParsedFontTrait + Sync + 'static>(

689

210

    cache: &mut LayoutCache,

690

210

    text_cache: &mut TextLayoutCache,

691

210

    fragmentation_context: &mut FragmentationContext,

692

210

    new_dom: &StyledDom,

693

210

    viewport: LogicalRect,

694

210

    font_manager: &crate::font_traits::FontManager<T>,

695

210

    debug_messages: &mut Option<Vec<LayoutDebugMessage>>,

696

210

    image_cache: &azul_core::resources::ImageCache,

697

210

    get_system_time_fn: azul_core::task::GetSystemTimeCallback,

698

210

    _print_timing: bool,

699

210

) -> Result<()> {

700

    use crate::solver3::cache;

701

    use crate::window::LayoutWindow;

702

703

    // Create temporary context without counters for tree generation

704

210

    let mut counter_values = std::collections::HashMap::new();

705

210

    let empty_text_selections: BTreeMap<DomId, TextSelection> = BTreeMap::new();

706

210

    let mut ctx_temp = LayoutContext {

707

210

            reflowed_ifcs: std::collections::BTreeSet::new(),

708

210

        style_cache: Default::default(),

709

210

        scrollbar_style_cache: core::cell::RefCell::new(std::collections::HashMap::new()),

710

210

        styled_dom: new_dom,

711

210

        font_manager,

712

210

        text_selections: &empty_text_selections,

713

210

        debug_messages,

714

210

        counters: &mut counter_values,

715

210

        viewport_size: viewport.size,

716

210

        fragmentation_context: Some(fragmentation_context),

717

210

        cursor_is_visible: true, // Paged layout: cursor always visible

718

210

        cursor_locations: Vec::new(),   // Paged layout: no cursor

719

210

        preedit_text: None,

720

210

        cache_map: cache::LayoutCacheMap::default(),

721

210

        image_cache,

722

210

        content_overlay: None,

723

210

        system_style: None,

724

210

        get_system_time_fn,

725

210

};

726

727

    // --- Step 1: Tree Building & Invalidation ---

728

210

    let is_fresh_dom = cache.tree.is_none();

729

210

    let (mut new_tree, mut recon_result) = if is_fresh_dom {

730

        // Fast path: no old tree to diff against — build tree directly.

731

        use crate::solver3::layout_tree::generate_layout_tree;

732

196

        let new_tree = generate_layout_tree(&mut ctx_temp)?;

733

196

        let n = new_tree.nodes.len();

734

196

        let mut result = cache::ReconciliationResult::default();

735

196

        result.layout_roots.insert(new_tree.root);

736

196

        result.intrinsic_dirty = (0..n).collect::<std::collections::BTreeSet<_>>();

737

196

        (new_tree, result)

738

    } else {

739

        // Incremental path: diff old tree vs new DOM

740

14

        cache::reconcile_and_invalidate(&mut ctx_temp, cache, viewport, None)?

741

};

742

743

    // Step 1.2: Clear Taffy Caches for Dirty Nodes

744

2578

    for &node_idx in &recon_result.intrinsic_dirty {

745

2368

        if let Some(warm) = new_tree.warm_mut(LayoutNodeId::new(node_idx)) {

746

2368

            warm.taffy_cache.clear();

747

2368

            warm.measured_content_sizes = (None, None);

748

2368

749

750

751

    // Step 1.3: Compute CSS Counters

752

210

753

210

        let _p = crate::probe::Probe::span("frag_compute_counters");

754

210

        cache::compute_counters(new_dom, &new_tree, &mut counter_values);

755

210

756

757

    // Step 1.4: Resize and invalidate per-node cache (Taffy-inspired 9+1 slot cache)

758

    // Move cache_map out of LayoutCache for the duration of layout.

759

210

    let mut cache_map = std::mem::take(&mut cache.cache_map);

760

210

    cache_map.resize_to_tree(new_tree.nodes.len());

761

2578

    for &node_idx in &recon_result.intrinsic_dirty {

762

2368

        cache_map.mark_dirty(node_idx, &new_tree.nodes);

763

2368

764

416

    for &node_idx in &recon_result.layout_roots {

765

206

        cache_map.mark_dirty(node_idx, &new_tree.nodes);

766

206

767

768

    // Now create the real context with computed counters and fragmentation

769

210

    let mut ctx = LayoutContext {

770

210

            reflowed_ifcs: std::collections::BTreeSet::new(),

771

210

        style_cache: Default::default(),

772

210

        scrollbar_style_cache: core::cell::RefCell::new(std::collections::HashMap::new()),

773

210

        styled_dom: new_dom,

774

210

        font_manager,

775

210

        text_selections: &empty_text_selections,

776

210

        debug_messages,

777

210

        counters: &mut counter_values,

778

210

        viewport_size: viewport.size,

779

210

        fragmentation_context: Some(fragmentation_context),

780

210

        cursor_is_visible: true, // Paged layout: cursor always visible

781

210

        cursor_locations: Vec::new(),   // Paged layout: no cursor

782

210

        preedit_text: None,

783

210

        cache_map,

784

210

        image_cache,

785

210

        content_overlay: None,

786

210

        system_style: None,

787

210

        get_system_time_fn,

788

210

};

789

790

    // --- Step 1.5: Early Exit Optimization ---

791

210

    if recon_result.is_clean() {

792

4

        debug_log!(ctx, "No changes, layout cache is clean");

793

4

        let tree = cache.tree.as_ref().ok_or(LayoutError::InvalidTree)?;

794

795

4

        let (scroll_ids, scroll_id_to_node_id) = LayoutWindow::compute_scroll_ids(tree, new_dom);

796

4

        cache.scroll_ids = scroll_ids;

797

4

        cache.scroll_id_to_node_id = scroll_id_to_node_id;

798

799

4

        return Ok(());

800

206

801

802

    // --- Step 2: Incremental Layout Loop ---

803

206

    let p_clone_pos = crate::probe::Probe::span("frag_clone_positions");

804

206

    let mut calculated_positions = cache.calculated_positions.clone();

805

206

    drop(p_clone_pos);

806

206

    let mut loop_count = 0;

807

    loop {

808

206

        loop_count += 1;

809

206

        if loop_count > 10 {

810

            break;

811

206

812

813

206

        calculated_positions.clone_from(&cache.calculated_positions);

814

206

        let mut reflow_needed_for_scrollbars = false;

815

816

206

        let _p_intrinsic = crate::probe::Probe::span("frag_intrinsic_sizes");

817

206

        crate::solver3::sizing::calculate_intrinsic_sizes(

818

206

            &mut ctx,

819

206

            &mut new_tree,

820

206

            text_cache,

821

206

            &recon_result.intrinsic_dirty,

822

)?;

823

824

412

        for &root_idx in &recon_result.layout_roots {

825

206

            let (cb_pos, cb_size) = super::get_containing_block_for_node(

826

206

                &new_tree,

827

206

                new_dom,

828

206

                root_idx,

829

206

                &calculated_positions,

830

206

                viewport,

831

206

);

832

833

            // For ROOT nodes (no parent), we need to account for their margin.

834

            // The containing block position from viewport is (0, 0), but the root's

835

            // content starts at (margin + border + padding, margin + border + padding).

836

206

            let root_node = &new_tree.nodes[root_idx];

837

206

            let root_bp = root_node.box_props.unpack();

838

206

            let is_root_with_margin = root_node.parent.is_none()

839

206

                && (root_bp.margin.left != 0.0 || root_bp.margin.top != 0.0);

840

841

206

            let adjusted_cb_pos = if is_root_with_margin {

842

48

                LogicalPosition::new(

843

48

                    cb_pos.x + root_bp.margin.left,

844

48

                    cb_pos.y + root_bp.margin.top,

845

846

            } else {

847

158

                cb_pos

848

};

849

850

206

            cache::calculate_layout_for_subtree(

851

206

                &mut ctx,

852

206

                &mut new_tree,

853

206

                text_cache,

854

206

                root_idx,

855

206

                adjusted_cb_pos,

856

206

                cb_size,

857

206

                &mut calculated_positions,

858

206

                &mut reflow_needed_for_scrollbars,

859

206

                &mut cache.float_cache,

860

206

                cache::ComputeMode::PerformLayout,

861

)?;

862

863

            // For root nodes, the position should be at (margin.left, margin.top) relative

864

            // to the viewport origin, because the margin creates space between the viewport

865

            // edge and the element's border-box.

866

206

            if !super::pos_contains(&calculated_positions, root_idx) {

867

196

                let root_position = if is_root_with_margin {

868

45

                    adjusted_cb_pos

869

                } else {

870

151

                    cb_pos

871

};

872

196

                super::pos_set(&mut calculated_positions, root_idx, root_position);

873

10

874

875

876

206

        cache::reposition_clean_subtrees(

877

206

            new_dom,

878

206

            &new_tree,

879

206

            &recon_result.layout_roots,

880

206

            &mut calculated_positions,

881

);

882

883

206

        if reflow_needed_for_scrollbars {

884

            debug_log!(ctx, "Scrollbars changed container size, starting full reflow...");

885

            recon_result.layout_roots.clear();

886

            recon_result.layout_roots.insert(new_tree.root);

887

            recon_result.intrinsic_dirty = (0..new_tree.nodes.len()).collect();

888

            continue;

889

206

890

891

206

        break;

892

893

894

    // --- Step 3: Adjust Positions ---

895

206

    crate::solver3::positioning::adjust_relative_positions(

896

206

        &mut ctx,

897

206

        &new_tree,

898

206

        &mut calculated_positions,

899

206

        viewport,

900

);

901

902

206

    crate::solver3::positioning::position_out_of_flow_elements(

903

206

        &mut ctx,

904

206

        &mut new_tree,

905

206

        text_cache,

906

206

        &mut calculated_positions,

907

206

        viewport,

908

);

909

910

    // --- Step 3.75: Compute Stable Scroll IDs ---

911

206

    let (scroll_ids, scroll_id_to_node_id) = LayoutWindow::compute_scroll_ids(&new_tree, new_dom);

912

913

    // --- Step 4: Update Cache ---

914

206

    let cache_map_back = std::mem::take(&mut ctx.cache_map);

915

916

206

    cache.tree = Some(new_tree);

917

206

    cache.previous_positions = std::mem::replace(&mut cache.calculated_positions, calculated_positions);

918

206

    cache.viewport = Some(viewport);

919

206

    cache.scroll_ids = scroll_ids;

920

206

    cache.scroll_id_to_node_id = scroll_id_to_node_id;

921

206

    cache.counters = counter_values;

922

206

    cache.cache_map = cache_map_back;

923

924

206

    Ok(())

925

210

926

927

/// One width-section's pagination within a sectioned document.

928

#[derive(Debug, Clone)]

929

pub struct SectionPagination {

930

    /// 0-based GLOBAL index of the section's first page.

931

    pub first_page: usize,

932

    /// The width this section's content was laid out (re-wrapped) against.

933

    pub content_width: f32,

934

    /// Pagination of the section's OWN content (Y coordinates are local to

935

    /// the section's layout, page indices local to the section).

936

    pub info: crate::solver3::page_breaks::PaginationInfo,

937

938

939

/// Result of [`compute_sectioned_pagination`]: per-width-section pagination.

940

#[derive(Debug, Clone)]

941

pub struct SectionedPaginationInfo {

942

    pub sections: Vec<SectionPagination>,

943

944

945

impl SectionedPaginationInfo {

946

    /// Total page count across all sections.

947

    #[must_use]

948

2

    pub fn page_count(&self) -> usize {

949

2

        self.sections.iter().map(|s| s.info.page_count).sum::<usize>().max(1)

950

2

951

952

953

/// The child-index path (root → node) of the first block-level box whose top

954

/// edge sits at/after `y` — the SPINE the fragmentainer cut runs along.

955

///

956

/// `document_edit::split_dom_at_path` consumes this path to cut the

957

/// reconstructed document for the next section's re-wrap. Ties (equal Y)

958

/// resolve to the SHALLOWEST node so the cut spine stays as high as possible.

959

#[must_use]

960

163

pub fn spine_path_at_y(

961

163

    tree: &crate::solver3::layout_tree::LayoutTree,

962

163

    positions: &crate::solver3::PositionVec,

963

163

    styled_dom: &StyledDom,

964

163

    y: f32,

965

163

) -> Option<Vec<u32>> {

966

163

    let hierarchy = styled_dom.node_hierarchy.as_container();

967

167

    let depth_of = |mut n: NodeId| -> u32 {

968

104

        let mut d = 0;

969

289

        while let Some(p) = hierarchy.get(n).and_then(azul_core::styled_dom::NodeHierarchyItem::parent_id) {

970

185

            d += 1;

971

185

            n = p;

972

185

973

104

974

104

};

975

976

163

    let mut best: Option<(f32, u32, NodeId)> = None;

977

1062

    for idx in 0..tree.nodes.len() {

978

1062

        let Some(node) = tree.get(LayoutNodeId::new(idx)) else { continue };

979

1062

        let Some(dom_id) = node.dom_node_id else { continue };

980

1062

        if !crate::solver3::layout_tree::is_block_level(styled_dom, dom_id) {

981

378

            continue;

982

684

983

684

        let Some(pos) = crate::solver3::pos_get(positions, idx) else {

984

            continue;

985

};

986

684

        if pos.y < y - 0.5 {

987

580

            continue;

988

104

989

104

        let d = depth_of(dom_id);

990

104

        let better = match &best {

991

82

            None => true,

992

22

            Some((by, bd, _)) => pos.y < *by - 0.01 || ((pos.y - by).abs() <= 0.01 && d < *bd),

993

};

994

104

        if better {

995

82

            best = Some((pos.y, d, dom_id));

996

85

997

998

999

163

    let (_, _, node) = best?;

1000

    // Child-index path root → node.

1001

82

    let mut path: Vec<u32> = Vec::new();

1002

82

    let mut cur = node;

1003

227

    while let Some(parent) = hierarchy.get(cur).and_then(azul_core::styled_dom::NodeHierarchyItem::parent_id) {

1004

145

        let mut i: u32 = 0;

1005

145

        let mut c = hierarchy.get(parent).and_then(|h| h.first_child_id(parent));

1006

409

        while let Some(cc) = c {

1007

409

            if cc == cur {

1008

145

                break;

1009

264

1010

264

            i += 1;

1011

264

            c = hierarchy

1012

264

                .get(cc)

1013

264

                .and_then(azul_core::styled_dom::NodeHierarchyItem::next_sibling_id);

1014

1015

145

        path.push(i);

1016

145

        cur = parent;

1017

1018

82

    path.reverse();

1019

82

    Some(path)

1020

163

1021

1022

/// Materialize the tail of a [`PageSequence`] starting at `first_page` as a

1023

/// standalone sequence (local page 0 = global `first_page`). Bounded

1024

/// override copying; parity/first-page variation collapses into explicit

1025

/// overrides so no offset arithmetic leaks into the break pass.

1026

#[must_use]

1027

3

fn materialize_sequence_tail(

1028

3

    seq: &crate::solver3::pagination::PageSequence,

1029

3

    first_page: usize,

1030

3

    scan: usize,

1031

3

) -> crate::solver3::pagination::PageSequence {

1032

3

    let mut out =

1033

3

        crate::solver3::pagination::PageSequence::uniform(seq.default.clone());

1034

1025

    for local in 0..scan {

1035

1025

        let setup = seq.setup_for_page(first_page + local);

1036

        // Geometry decides pagination; decoration differences don't need an

1037

        // override entry (the slicer reads decoration off the ORIGINAL

1038

        // sequence by global page index).

1039

1025

        let differs = (setup.content_width() - out.default.content_width()).abs() >= 0.5

1040

1024

            || (setup.content_height() - out.default.content_height()).abs() >= 0.5;

1041

1025

        if differs {

1042

1

            out.overrides.insert(local, setup.clone());

1043

1024

1044

1045

3

out

1046

3

1047

1048

/// Fragmentainer-flow pagination with PER-SECTION WIDTH RE-WRAP.

1049

///

1050

/// [`PageSequence::width_sections`] partitions pages into maximal

1051

/// equal-width runs (the classic office suites model: page setup changes at section

1052

/// breaks). Content lays out ONCE per section at that section's width; when

1053

/// a section's page budget fills, the document is CUT along the spine of

1054

/// the first block on the next page ([`spine_path_at_y`] +

1055

/// [`crate::document_edit::split_dom_at_path`]), the tail re-styles against

1056

/// the retained author css, and the flow continues in the next section at

1057

/// its width. This replaces the `has_uniform_width()` degradation for the

1058

/// document-pagination path.

1059

///

1060

/// Limits (staged): the cut is block-granular (a paragraph straddling a

1061

/// section boundary moves wholly to the next section rather than splitting

1062

/// mid-line — the classic office-suite behavior for section breaks); floats/positioned boxes

1063

/// do not carry across sections.

1064

///

1065

/// # Errors

1066

///

1067

/// Returns a `LayoutError` if any section's layout fails.

1068

// xml: `document_edit` (the spine-cut applier) lives behind text_layout+xml.

1069

#[cfg(all(feature = "text_layout", feature = "xml"))]

1070

#[allow(clippy::too_many_arguments)]

1071

2

pub fn compute_sectioned_pagination<T, F>(

1072

2

    styled_dom: &StyledDom,

1073

2

    page_height: f32,

1074

2

    font_manager: &mut crate::font_traits::FontManager<T>,

1075

2

    renderer_resources: &RendererResources,

1076

2

    id_namespace: azul_core::resources::IdNamespace,

1077

2

    dom_id: DomId,

1078

2

    font_loader: F,

1079

2

    page_config: &FakePageConfig,

1080

2

    sequence: &crate::solver3::pagination::PageSequence,

1081

2

    image_cache: &azul_core::resources::ImageCache,

1082

2

    get_system_time_fn: azul_core::task::GetSystemTimeCallback,

1083

2

) -> Result<SectionedPaginationInfo>

1084

2

where

1085

2

    T: ParsedFontTrait + Sync + 'static,

1086

2

    F: Fn(

1087

2

            std::sync::Arc<rust_fontconfig::FontBytes>,

1088

2

            usize,

1089

2

        ) -> std::result::Result<T, crate::text3::cache::LayoutError>

1090

2

        + Copy,

1091

1092

    use azul_core::geom::{LogicalPosition, LogicalRect, LogicalSize};

1093

1094

    const SECTION_SCAN: usize = 512;

1095

2

    let sections = sequence.width_sections(SECTION_SCAN);

1096

1097

    // Tails re-style against the ORIGINAL document's author css — a Dom

1098

    // reconstructed from a StyledDom carries it in `.css`, but `create`'s

1099

    // css parameter is the reliable non-lossy channel.

1100

2

    let author_css = styled_dom

1101

2

        .get_css_property_cache()

1102

2

        .retained_author_css

1103

2

        .clone();

1104

1105

2

    let mut out = SectionedPaginationInfo { sections: Vec::new() };

1106

    // The working document: exact styled_dom for section 0; reconstructed +

1107

    // cut tails afterwards. The reconstruction happens lazily (only when a

1108

    // second section actually receives content).

1109

2

    let mut working: Option<azul_core::dom::Dom> = None;

1110

2

    let mut working_styled: Option<StyledDom> = None;

1111

1112

3

    for (k, sec) in sections.iter().enumerate() {

1113

3

        let is_last = k + 1 == sections.len();

1114

3

        let section_styled: &StyledDom = working_styled.as_ref().map_or(styled_dom, |s| s);

1115

1116

3

        let content_size = LogicalSize::new(sec.content_width, page_height);

1117

3

        let viewport = LogicalRect {

1118

3

            origin: LogicalPosition::zero(),

1119

3

            size: content_size,

1120

3

};

1121

3

        let mut cache = LayoutCache::default();

1122

3

        let mut text_cache = TextLayoutCache::new();

1123

3

        let frag = FragmentationContext::new_paged(content_size);

1124

3

        let mut cfg = page_config.clone();

1125

3

        cfg.page_sequence = Some(materialize_sequence_tail(

1126

3

            sequence,

1127

3

            sec.first_page,

1128

3

            sec.page_count.unwrap_or(SECTION_SCAN).min(SECTION_SCAN),

1129

3

));

1130

1131

3

        let info = compute_document_pagination(

1132

3

            &mut cache,

1133

3

            &mut text_cache,

1134

3

            frag,

1135

3

            section_styled,

1136

3

            viewport,

1137

3

            font_manager,

1138

3

            &BTreeMap::new(),

1139

3

            &mut None,

1140

3

            None,

1141

3

            renderer_resources,

1142

3

            id_namespace,

1143

3

            dom_id,

1144

3

            font_loader,

1145

3

            cfg,

1146

3

            image_cache,

1147

3

            get_system_time_fn,

1148

)?;

1149

1150

3

        let budget = sec.page_count.unwrap_or(usize::MAX);

1151

3

        if is_last || info.page_count <= budget {

1152

            // Content ends inside this section.

1153

2

            out.sections.push(SectionPagination {

1154

2

                first_page: sec.first_page,

1155

2

                content_width: sec.content_width,

1156

2

                info,

1157

2

});

1158

2

            return Ok(out);

1159

1

1160

1161

        // Section overflows its page budget: cut at the end of its last page

1162

        // and flow the tail into the next section at ITS width.

1163

1

        let cut_y = info.breaks.get(budget - 1).map_or(info.total_content_height, |b| b.y);

1164

1

        let tree = cache.tree.as_ref().ok_or(LayoutError::InvalidTree)?;

1165

1

        let spine = spine_path_at_y(tree, &cache.calculated_positions, section_styled, cut_y);

1166

1167

1

        let working_dom = working

1168

1

            .take()

1169

1

            .map_or_else(|| section_styled.reconstruct_dom_subtree(None), |d| d);

1170

        // No block starts after the cut: everything fits after all.

1171

1

        let Some(path) = &spine else {

1172

            out.sections.push(SectionPagination {

1173

                first_page: sec.first_page,

1174

                content_width: sec.content_width,

1175

                info,

1176

});

1177

            return Ok(out);

1178

};

1179

        // The head's pages come from `info` (trimmed below); only the tail

1180

        // flows on.

1181

1

        let (_head, tail) = crate::document_edit::split_dom_at_path(&working_dom, path);

1182

1183

1

        let mut trimmed = info;

1184

1

        trimmed.page_count = budget;

1185

1

        trimmed.breaks.truncate(budget.saturating_sub(1));

1186

1

        trimmed.total_content_height = cut_y;

1187

1

        out.sections.push(SectionPagination {

1188

1

            first_page: sec.first_page,

1189

1

            content_width: sec.content_width,

1190

1

            info: trimmed,

1191

1

});

1192

1193

        // StyledDom::create consumes the Dom's node data — style a CLONE and

1194

        // keep the pristine tail as the working document for the next cut.

1195

1

        let mut style_me = tail.clone();

1196

1

        working_styled = Some(StyledDom::create(&mut style_me, author_css.clone()));

1197

1

        working = Some(tail);

1198

1199

1200

    Ok(out)

1201

2

1202

1203

#[cfg(all(test, feature = "text_layout"))]

1204

#[allow(clippy::float_cmp)]

1205

mod autotest_generated {

1206

    use azul_core::{

1207

        dom::Dom,

1208

        resources::{IdNamespace, ImageCache},

1209

        task::{get_system_time_libstd, GetSystemTimeCallback},

1210

};

1211

    use rust_fontconfig::FcFontCache;

1212

1213

    use super::*;

1214

    use crate::{font_traits::FontManager, text3::default::PathLoader};

1215

1216

    // ---------------------------------------------------------------------

1217

    // Harness

1218

//

1219

    // Every DOM below is deliberately TEXT-FREE, so no font ever has to be

1220

    // resolved and the font cache can stay empty (no system-font I/O, so the

1221

    // tests are hermetic and identical on every machine).

1222

    // ---------------------------------------------------------------------

1223

1224

    /// The crate's only `ParsedFontTrait` impl (`text3::default`).

1225

    type TestFont = azul_css::props::basic::FontRef;

1226

1227

    fn time_fn() -> GetSystemTimeCallback {

1228

        GetSystemTimeCallback {

1229

            cb: get_system_time_libstd,

1230

1231

1232

1233

    fn font_manager() -> FontManager<TestFont> {

1234

        FontManager::new(FcFontCache::default()).expect("FontManager::new must not fail")

1235

1236

1237

    fn viewport(width: f32, height: f32) -> LogicalRect {

1238

        LogicalRect {

1239

            origin: LogicalPosition::zero(),

1240

            size: LogicalSize::new(width, height),

1241

1242

1243

1244

    fn paged(width: f32, height: f32) -> FragmentationContext {

1245

        FragmentationContext::new_paged(LogicalSize::new(width, height))

1246

1247

1248

    /// `<body>` with `n` painted, 200px-tall divs — a document ~`n * 200`px tall.

1249

    /// The background is what makes each div emit a display-list item, and the

1250

    /// paginator derives the document height from those items.

1251

    fn doc(n: usize) -> StyledDom {

1252

        let children: Vec<Dom> = (0..n).map(|_| Dom::create_div()).collect();

1253

        let mut dom = Dom::create_body().with_children(children.into());

1254

        let css = azul_css::parser2::new_from_str(

1255

            "div { height: 200px; width: 100px; background-color: red; }",

1256

1257

.0;

1258

        StyledDom::create(&mut dom, css)

1259

1260

1261

    fn run_with(

1262

        cache: &mut LayoutCache,

1263

        font_manager: &mut FontManager<TestFont>,

1264

        fragmentation_context: FragmentationContext,

1265

        dom: &StyledDom,

1266

        vp: LogicalRect,

1267

        page_config: FakePageConfig,

1268

    ) -> Result<Vec<DisplayList>> {

1269

        let loader = PathLoader::new();

1270

        let mut text_cache = TextLayoutCache::new();

1271

        let mut debug_messages = None;

1272

        layout_document_paged_with_config(

1273

            cache,

1274

            &mut text_cache,

1275

            fragmentation_context,

1276

            dom,

1277

vp,

1278

            font_manager,

1279

            &BTreeMap::new(),

1280

            &mut debug_messages,

1281

            None,

1282

            &RendererResources::default(),

1283

            IdNamespace(0),

1284

            DomId::ROOT_ID,

1285

            |bytes: std::sync::Arc<rust_fontconfig::FontBytes>, index: usize| {

1286

                loader.load_font_shared(bytes, index)

1287

},

1288

            page_config,

1289

            &ImageCache::default(),

1290

            time_fn(),

1291

            false,

1292

1293

1294

1295

    /// One-shot paged layout against a fresh cache.

1296

    fn run(

1297

        fragmentation_context: FragmentationContext,

1298

        dom: &StyledDom,

1299

        vp: LogicalRect,

1300

        page_config: FakePageConfig,

1301

    ) -> Result<Vec<DisplayList>> {

1302

        let mut cache = LayoutCache::default();

1303

        let mut font_manager = font_manager();

1304

        run_with(

1305

            &mut cache,

1306

            &mut font_manager,

1307

            fragmentation_context,

1308

            dom,

1309

vp,

1310

            page_config,

1311

1312

1313

1314

    /// Number of pages for a fresh, default-configured paged layout.

1315

    fn page_count(fragmentation_context: FragmentationContext, dom: &StyledDom, vp: LogicalRect) -> usize {

1316

        run(fragmentation_context, dom, vp, FakePageConfig::new())

1317

            .expect("paged layout must not fail")

1318

            .len()

1319

1320

1321

    fn item_counts(pages: &[DisplayList]) -> Vec<usize> {

1322

        pages.iter().map(|p| p.items.len()).collect()

1323

1324

1325

    fn compute(

1326

        cache: &mut LayoutCache,

1327

        fragmentation_context: &mut FragmentationContext,

1328

        dom: &StyledDom,

1329

        vp: LogicalRect,

1330

    ) -> Result<()> {

1331

        let font_manager = font_manager();

1332

        let mut text_cache = TextLayoutCache::new();

1333

        let mut debug_messages = None;

1334

        compute_layout_with_fragmentation(

1335

            cache,

1336

            &mut text_cache,

1337

            fragmentation_context,

1338

            dom,

1339

vp,

1340

            &font_manager,

1341

            &mut debug_messages,

1342

            &ImageCache::default(),

1343

            time_fn(),

1344

            false,

1345

1346

1347

1348

    fn tree_node_count(cache: &LayoutCache) -> usize {

1349

        cache.tree.as_ref().expect("layout must cache a tree").nodes.len()

1350

1351

1352

    // ---------------------------------------------------------------------

1353

    // Baseline invariants

1354

//

1355

    // NOTE (not tested here — the assertions would hang the suite):

1356

    // `calculate_page_break_positions` (display_list.rs) advances by

1357

    // `y += normal_page_height` while `y < total_height`. Two reachable

1358

    // inputs make that loop non-terminating while pushing into an unbounded

1359

    // Vec (hang → OOM), and both are reachable from these two entry points:

1360

    //   1. a tiny positive page height (e.g. 1e-30) — it clears the

1361

    //      `page_content_height <= 0.0` guard, but `y += 1e-30` stops moving

1362

    //      `y` as soon as the step falls below `y`'s ULP;

1363

    //   2. `skip_first_page(true)` with `header_height + footer_height`

1364

    //      >= the page height — `normal_page_height` goes negative, so `y`

1365

    //      walks *backwards* away from `total_height` forever.

1366

    // The tests below stay strictly on the safe side of both, and the guarded

1367

    // variants (0 / negative / NaN / inf / f32::MAX heights, and an oversized

1368

    // header WITHOUT skip_first_page) are asserted instead.

1369

    // ---------------------------------------------------------------------

1370

1371

    #[test]

1372

    fn continuous_context_returns_exactly_one_display_list() {

1373

        let dom = doc(5);

1374

        let pages = run(

1375

            FragmentationContext::new_continuous(600.0),

1376

            &dom,

1377

            viewport(600.0, 400.0),

1378

            FakePageConfig::new(),

1379

1380

        .expect("continuous layout must not fail");

1381

1382

        assert_eq!(pages.len(), 1, "continuous media is never paginated");

1383

        assert!(

1384

            !pages[0].items.is_empty(),

1385

            "painted divs must produce display-list items — the rest of this \

1386

             module's page-count assertions depend on it"

1387

);

1388

1389

1390

    #[test]

1391

    fn tall_document_splits_into_multiple_pages() {

1392

        // ~1000px of content, 200px pages.

1393

        let pages = run(

1394

            paged(600.0, 200.0),

1395

            &doc(5),

1396

            viewport(600.0, 400.0),

1397

            FakePageConfig::new(),

1398

1399

        .expect("paged layout must not fail");

1400

1401

        assert!(

1402

            pages.len() >= 2,

1403

            "1000px of content on 200px pages must paginate, got {} page(s)",

1404

            pages.len()

1405

);

1406

1407

1408

    #[test]

1409

    fn empty_document_still_yields_one_page() {

1410

        // A document with nothing to paint has height 0 — the paginator must

1411

        // still hand back a page rather than an empty vec (a zero-page PDF).

1412

        let pages = run(

1413

            paged(600.0, 200.0),

1414

            &StyledDom::default(),

1415

            viewport(600.0, 400.0),

1416

            FakePageConfig::new(),

1417

1418

        .expect("empty document must lay out");

1419

1420

        assert_eq!(pages.len(), 1, "a zero-height document is still one page");

1421

1422

1423

    // ---------------------------------------------------------------------

1424

    // Numeric: degenerate page sizes (zero / negative / NaN / inf / MIN / MAX)

1425

    // ---------------------------------------------------------------------

1426

1427

    #[test]

1428

    fn zero_page_height_yields_a_single_page() {

1429

        let pages = run(

1430

            paged(600.0, 0.0),

1431

            &doc(5),

1432

            viewport(600.0, 400.0),

1433

            FakePageConfig::new(),

1434

1435

        .expect("a zero-height page must not fail layout");

1436

1437

        assert_eq!(

1438

            pages.len(),

1439

1,

1440

            "a page of height 0 cannot be filled — the slicer must bail out to \

1441

             a single unpaginated page instead of dividing by zero"

1442

);

1443

1444

1445

    #[test]

1446

    fn zero_page_size_in_both_axes_does_not_panic() {

1447

        let pages = run(

1448

            paged(0.0, 0.0),

1449

            &doc(3),

1450

            viewport(0.0, 0.0),

1451

            FakePageConfig::new(),

1452

1453

        .expect("a fully degenerate 0x0 page must not fail layout");

1454

1455

        assert_eq!(pages.len(), 1);

1456

1457

1458

    #[test]

1459

    fn negative_page_height_yields_a_single_page() {

1460

        let pages = run(

1461

            paged(600.0, -500.0),

1462

            &doc(5),

1463

            viewport(600.0, 400.0),

1464

            FakePageConfig::new(),

1465

1466

        .expect("a negative page height must not fail layout");

1467

1468

        assert_eq!(

1469

            pages.len(),

1470

1,

1471

            "a negative page height must not produce a negative/infinite page count"

1472

);

1473

1474

1475

    #[test]

1476

    fn nan_page_size_does_not_panic_and_yields_at_least_one_page() {

1477

        // NaN slips past BOTH `<= 0.0` and `>= f32::MAX` guards (every NaN

1478

        // comparison is false), so this is the case most likely to reach the

1479

        // break-position math with a poisoned step.

1480

        let pages = run(

1481

            paged(f32::NAN, f32::NAN),

1482

            &doc(5),

1483

            viewport(600.0, 400.0),

1484

            FakePageConfig::new(),

1485

1486

        .expect("a NaN page size must not fail layout");

1487

1488

        assert_eq!(

1489

            pages.len(),

1490

1,

1491

            "a NaN page height cannot advance the break cursor, so the whole \

1492

             document must stay on one page (and the break sort must not see a NaN)"

1493

);

1494

1495

1496

    #[test]

1497

    fn infinite_page_height_yields_a_single_page() {

1498

        let pages = run(

1499

            paged(600.0, f32::INFINITY),

1500

            &doc(5),

1501

            viewport(600.0, 400.0),

1502

            FakePageConfig::new(),

1503

1504

        .expect("an infinite page height must not fail layout");

1505

1506

        assert_eq!(pages.len(), 1, "an infinitely tall page holds everything");

1507

1508

1509

    #[test]

1510

    fn f32_max_page_height_yields_a_single_page() {

1511

        // f32::MAX is the sentinel `FragmentationContext::Continuous` reports,

1512

        // so a *paged* context carrying it must degrade to the same behaviour

1513

        // rather than attempting MAX/step pages.

1514

        let pages = run(

1515

            paged(600.0, f32::MAX),

1516

            &doc(5),

1517

            viewport(600.0, 400.0),

1518

            FakePageConfig::new(),

1519

1520

        .expect("f32::MAX page height must not fail layout");

1521

1522

        assert_eq!(pages.len(), 1);

1523

1524

1525

    #[test]

1526

    fn f32_min_page_height_yields_a_single_page() {

1527

        // f32::MIN is the most-negative finite float, not the smallest positive.

1528

        let pages = run(

1529

            paged(f32::MIN, f32::MIN),

1530

            &doc(5),

1531

            viewport(600.0, 400.0),

1532

            FakePageConfig::new(),

1533

1534

        .expect("f32::MIN page size must not fail layout");

1535

1536

        assert_eq!(pages.len(), 1);

1537

1538

1539

    // ---------------------------------------------------------------------

1540

    // Numeric: degenerate viewports

1541

    // ---------------------------------------------------------------------

1542

1543

    #[test]

1544

    fn negative_viewport_size_does_not_panic() {

1545

        let pages = run(

1546

            paged(600.0, 200.0),

1547

            &doc(5),

1548

            viewport(-100.0, -100.0),

1549

            FakePageConfig::new(),

1550

1551

        .expect("a negative viewport must not fail layout");

1552

1553

        assert!(!pages.is_empty(), "layout must always emit at least one page");

1554

1555

1556

    #[test]

1557

    fn nan_viewport_does_not_panic() {

1558

        let pages = run(

1559

            paged(600.0, 200.0),

1560

            &doc(5),

1561

            viewport(f32::NAN, f32::NAN),

1562

            FakePageConfig::new(),

1563

1564

        .expect("a NaN viewport must not fail layout");

1565

1566

        assert!(!pages.is_empty(), "layout must always emit at least one page");

1567

1568

1569

    #[test]

1570

    fn huge_viewport_does_not_panic() {

1571

        // Paired with an f32::MAX page height on purpose: pagination short-circuits,

1572

        // so this exercises the layout/display-list path at the numeric limit

1573

        // without asking the slicer to walk MAX-sized content in finite steps.

1574

        let result = run(

1575

            paged(f32::MAX, f32::MAX),

1576

            &doc(3),

1577

            viewport(f32::MAX, f32::MAX),

1578

            FakePageConfig::new(),

1579

);

1580

1581

        match result {

1582

            Ok(pages) => assert_eq!(pages.len(), 1),

1583

            // Failing cleanly at the numeric limit is acceptable; panicking is not.

1584

            Err(e) => {

1585

                let _ = e.to_string();

1586

1587

1588

1589

1590

    // ---------------------------------------------------------------------

1591

    // Numeric: monotonicity of the page count

1592

    // ---------------------------------------------------------------------

1593

1594

    #[test]

1595

    fn shorter_pages_never_produce_fewer_pages() {

1596

        let dom = doc(5);

1597

        let vp = viewport(600.0, 400.0);

1598

1599

        let tall = page_count(paged(600.0, 400.0), &dom, vp);

1600

        let short = page_count(paged(600.0, 100.0), &dom, vp);

1601

1602

        assert!(

1603

            short >= tall,

1604

            "halving the page height must not shrink the page count ({short} < {tall})"

1605

);

1606

1607

1608

    #[test]

1609

    fn more_content_never_produces_fewer_pages() {

1610

        let vp = viewport(600.0, 400.0);

1611

        let frag = paged(600.0, 200.0);

1612

1613

        let few = page_count(frag, &doc(3), vp);

1614

        let many = page_count(frag, &doc(12), vp);

1615

1616

        assert!(

1617

            many >= few,

1618

            "4x the content must not shrink the page count ({many} < {few})"

1619

);

1620

1621

1622

    // ---------------------------------------------------------------------

1623

    // Headers / footers

1624

    // ---------------------------------------------------------------------

1625

1626

    #[test]

1627

    fn header_and_footer_taller_than_the_page_yield_a_single_page() {

1628

        // header + footer >= page height leaves negative room for content.

1629

        // Without `skip_first_page`, the first-page height goes <= 0 and the

1630

        // slicer must bail out to one page rather than dividing the document

1631

        // into a negative-height grid.

1632

        let config = FakePageConfig::new()

1633

            .with_header_page_numbers()

1634

            .with_footer_page_numbers()

1635

            .with_header_height(f32::MAX)

1636

            .with_footer_height(f32::MAX);

1637

1638

        let pages = run(paged(600.0, 200.0), &doc(5), viewport(600.0, 400.0), config)

1639

            .expect("an oversized header/footer must not fail layout");

1640

1641

        assert_eq!(

1642

            pages.len(),

1643

1,

1644

            "no content fits once the header/footer exceed the page — one page, not zero, \

1645

             not an unbounded number"

1646

);

1647

1648

1649

    #[test]

1650

    fn skip_first_page_with_sane_header_and_footer_still_paginates() {

1651

        let config = FakePageConfig::new()

1652

            .with_header_and_footer_page_numbers()

1653

            .with_header_height(20.0)

1654

            .with_footer_height(20.0)

1655

            .skip_first_page(true);

1656

1657

        let pages = run(paged(600.0, 300.0), &doc(5), viewport(600.0, 400.0), config)

1658

            .expect("paged layout with headers/footers must not fail");

1659

1660

        assert!(

1661

            pages.len() >= 2,

1662

            "1000px of content on 300px pages (260px usable after the first) must \

1663

             paginate, got {} page(s)",

1664

            pages.len()

1665

);

1666

1667

1668

    // ---------------------------------------------------------------------

1669

    // Determinism / cache reuse / wrapper equivalence

1670

    // ---------------------------------------------------------------------

1671

1672

    #[test]

1673

    fn paged_layout_is_deterministic_across_fresh_runs() {

1674

        let dom = doc(5);

1675

        let vp = viewport(600.0, 400.0);

1676

        let frag = paged(600.0, 200.0);

1677

1678

        let first = run(frag, &dom, vp, FakePageConfig::new()).expect("layout must not fail");

1679

        let second = run(frag, &dom, vp, FakePageConfig::new()).expect("layout must not fail");

1680

1681

        assert_eq!(first.len(), second.len(), "page count must be deterministic");

1682

        assert_eq!(

1683

            item_counts(&first),

1684

            item_counts(&second),

1685

            "per-page item counts must be deterministic"

1686

);

1687

1688

1689

    #[test]

1690

    fn reusing_a_warm_cache_reproduces_the_cold_result() {

1691

        // Adversarial: the second call takes the incremental/early-exit path

1692

        // through `compute_layout_with_fragmentation`. Same DOM, same viewport,

1693

        // same page size => byte-identical pagination, or the cache is stale.

1694

        let dom = doc(5);

1695

        let vp = viewport(600.0, 400.0);

1696

        let frag = paged(600.0, 200.0);

1697

1698

        let mut cache = LayoutCache::default();

1699

        let mut fm = font_manager();

1700

1701

        let cold = run_with(&mut cache, &mut fm, frag, &dom, vp, FakePageConfig::new())

1702

            .expect("cold layout must not fail");

1703

        let warm = run_with(&mut cache, &mut fm, frag, &dom, vp, FakePageConfig::new())

1704

            .expect("warm layout must not fail");

1705

1706

        assert_eq!(cold.len(), warm.len(), "cache reuse changed the page count");

1707

        assert_eq!(

1708

            item_counts(&cold),

1709

            item_counts(&warm),

1710

            "cache reuse changed the per-page item counts"

1711

);

1712

1713

1714

    #[test]

1715

    fn a_reused_cache_relaid_out_with_a_different_dom_matches_a_cold_run() {

1716

        // Adversarial: feed a cache warmed on a SHORT document a much longer

1717

        // one. The reconciled result must equal what a cold cache produces —

1718

        // page count must not depend on layout history.

1719

        let vp = viewport(600.0, 400.0);

1720

        let frag = paged(600.0, 200.0);

1721

        let short = doc(2);

1722

        let long = doc(9);

1723

1724

        let mut cache = LayoutCache::default();

1725

        let mut fm = font_manager();

1726

        let _ = run_with(&mut cache, &mut fm, frag, &short, vp, FakePageConfig::new())

1727

            .expect("first layout must not fail");

1728

        let reused = run_with(&mut cache, &mut fm, frag, &long, vp, FakePageConfig::new())

1729

            .expect("relayout must not fail");

1730

1731

        let cold = page_count(frag, &long, vp);

1732

1733

        assert_eq!(

1734

            reused.len(),

1735

            cold,

1736

            "a cache warmed on a 2-div document produced {} page(s) for the 9-div \

1737

             document, but a cold cache produces {}",

1738

            reused.len(),

1739

            cold

1740

);

1741

1742

1743

    #[test]

1744

    fn layout_document_paged_matches_its_documented_default_config() {

1745

        // `layout_document_paged` is documented as `..._with_config` with

1746

        // footer page numbers and no timing output. Assert that equivalence

1747

        // holds, so the wrapper can't silently drift from the delegate.

1748

        let dom = doc(5);

1749

        let vp = viewport(600.0, 400.0);

1750

        let frag = paged(600.0, 200.0);

1751

1752

        let mut cache = LayoutCache::default();

1753

        let mut text_cache = TextLayoutCache::new();

1754

        let mut fm = font_manager();

1755

        let mut debug_messages = None;

1756

        let loader = PathLoader::new();

1757

1758

        let via_wrapper = layout_document_paged(

1759

            &mut cache,

1760

            &mut text_cache,

1761

            frag,

1762

            &dom,

1763

vp,

1764

            &mut fm,

1765

            &BTreeMap::new(),

1766

            &mut debug_messages,

1767

            None,

1768

            &RendererResources::default(),

1769

            IdNamespace(0),

1770

            DomId::ROOT_ID,

1771

            |bytes: std::sync::Arc<rust_fontconfig::FontBytes>, index: usize| {

1772

                loader.load_font_shared(bytes, index)

1773

},

1774

            &ImageCache::default(),

1775

            time_fn(),

1776

1777

        .expect("layout_document_paged must not fail");

1778

1779

        let via_config = run(

1780

            frag,

1781

            &dom,

1782

vp,

1783

            FakePageConfig::new().with_footer_page_numbers(),

1784

1785

        .expect("layout_document_paged_with_config must not fail");

1786

1787

        assert_eq!(via_wrapper.len(), via_config.len());

1788

        assert_eq!(item_counts(&via_wrapper), item_counts(&via_config));

1789

1790

1791

    // ---------------------------------------------------------------------

1792

    // compute_layout_with_fragmentation (private)

1793

    // ---------------------------------------------------------------------

1794

1795

    #[test]

1796

    fn compute_layout_with_fragmentation_populates_the_cache() {

1797

        let dom = doc(3);

1798

        let vp = viewport(600.0, 400.0);

1799

        let mut cache = LayoutCache::default();

1800

        let mut frag = paged(600.0, 200.0);

1801

1802

        compute(&mut cache, &mut frag, &dom, vp).expect("layout must not fail");

1803

1804

        assert!(cache.tree.is_some(), "the layout tree must be cached");

1805

        assert!(

1806

            tree_node_count(&cache) >= 4,

1807

            "<body> plus 3 <div>s is at least 4 layout nodes"

1808

);

1809

        assert!(

1810

            !cache.calculated_positions.is_empty(),

1811

            "positions must be cached alongside the tree"

1812

);

1813

        assert_eq!(cache.viewport, Some(vp), "the layout viewport must be recorded");

1814

        assert!(

1815

            crate::solver3::pos_get(&cache.calculated_positions, 0).is_some(),

1816

            "the root node must have a position"

1817

);

1818

1819

1820

    #[test]

1821

    fn compute_layout_with_fragmentation_is_idempotent() {

1822

        let dom = doc(3);

1823

        let vp = viewport(600.0, 400.0);

1824

        let mut cache = LayoutCache::default();

1825

        let mut frag = paged(600.0, 200.0);

1826

1827

        compute(&mut cache, &mut frag, &dom, vp).expect("first layout must not fail");

1828

        let nodes = tree_node_count(&cache);

1829

        let positions = cache.calculated_positions.clone();

1830

1831

        // Second pass takes the "cache is clean" early-exit branch.

1832

        compute(&mut cache, &mut frag, &dom, vp).expect("second layout must not fail");

1833

1834

        assert_eq!(tree_node_count(&cache), nodes, "relayout changed the tree size");

1835

        assert_eq!(

1836

            cache.calculated_positions, positions,

1837

            "relayout of an unchanged DOM moved nodes"

1838

);

1839

1840

1841

    #[test]

1842

    fn compute_layout_with_fragmentation_tree_shape_is_independent_of_pagination() {

1843

        // Layout is continuous; pages are sliced afterwards by Y position. So a

1844

        // paged context must not add, drop, or split any layout node.

1845

        let dom = doc(4);

1846

        let vp = viewport(600.0, 400.0);

1847

1848

        let mut continuous_cache = LayoutCache::default();

1849

        let mut continuous = FragmentationContext::new_continuous(600.0);

1850

        compute(&mut continuous_cache, &mut continuous, &dom, vp)

1851

            .expect("continuous layout must not fail");

1852

1853

        let mut paged_cache = LayoutCache::default();

1854

        let mut paged_ctx = paged(600.0, 50.0);

1855

        compute(&mut paged_cache, &mut paged_ctx, &dom, vp).expect("paged layout must not fail");

1856

1857

        assert_eq!(

1858

            tree_node_count(&continuous_cache),

1859

            tree_node_count(&paged_cache),

1860

            "fragmentation must not change the layout tree"

1861

);

1862

        assert_eq!(

1863

            continuous_cache.calculated_positions, paged_cache.calculated_positions,

1864

            "fragmentation must not move nodes — pages are sliced from the same \

1865

             continuous canvas"

1866

);

1867

1868

1869

    #[test]

1870

    fn compute_layout_with_fragmentation_survives_degenerate_viewports() {

1871

        let dom = doc(3);

1872

1873

        for vp in [

1874

            viewport(0.0, 0.0),

1875

            viewport(-1.0, -1.0),

1876

            viewport(f32::NAN, f32::NAN),

1877

            viewport(f32::MIN, f32::MIN),

1878

] {

1879

            let mut cache = LayoutCache::default();

1880

            let mut frag = paged(600.0, 200.0);

1881

1882

            compute(&mut cache, &mut frag, &dom, vp)

1883

                .unwrap_or_else(|e| panic!("viewport {vp:?} failed layout: {e}"));

1884

1885

            assert!(

1886

                cache.tree.is_some(),

1887

                "viewport {vp:?} must still produce a layout tree"

1888

);

1889

1890

1891

1892

    #[test]

1893

    fn compute_layout_with_fragmentation_survives_degenerate_page_sizes() {

1894

        let dom = doc(3);

1895

        let vp = viewport(600.0, 400.0);

1896

1897

        for mut frag in [

1898

            paged(0.0, 0.0),

1899

            paged(600.0, -1.0),

1900

            paged(f32::NAN, f32::NAN),

1901

            paged(f32::INFINITY, f32::INFINITY),

1902

            paged(f32::MAX, f32::MAX),

1903

            paged(f32::MIN, f32::MIN),

1904

] {

1905

            let mut cache = LayoutCache::default();

1906

1907

            compute(&mut cache, &mut frag, &dom, vp)

1908

                .unwrap_or_else(|e| panic!("page size {frag:?} failed layout: {e}"));

1909

1910

            assert!(

1911

                cache.tree.is_some(),

1912

                "page size {frag:?} must still produce a layout tree"

1913

);

1914

1915

1916

1917

    // ==================================================================

1918

    // Sectioned pagination — fragmentainer WIDTH re-wrap

1919

    // ==================================================================

1920

1921

    fn setup(w: f32, h: f32) -> crate::solver3::pagination::PageSetup {

1922

        crate::solver3::pagination::PageSetup {

1923

            page_size: LogicalSize::new(w, h),

1924

            margins: crate::solver3::pagination::PageMargins {

1925

                top: 0.0,

1926

                right: 0.0,

1927

                bottom: 0.0,

1928

                left: 0.0,

1929

},

1930

            header_footer: Default::default(),

1931

1932

1933

1934

    #[test]

1935

    fn width_sections_partition_by_content_width() {

1936

        use crate::solver3::pagination::PageSequence;

1937

        let mut seq = PageSequence::uniform(setup(600.0, 400.0));

1938

        seq.overrides.insert(0, setup(300.0, 400.0));

1939

        let sections = seq.width_sections(64);

1940

        assert_eq!(sections.len(), 2);

1941

        assert_eq!(sections[0].first_page, 0);

1942

        assert_eq!(sections[0].page_count, Some(1));

1943

        assert!((sections[0].content_width - 300.0).abs() < 0.5);

1944

        assert_eq!(sections[1].first_page, 1);

1945

        assert_eq!(sections[1].page_count, None, "tail is open-ended");

1946

        assert!((sections[1].content_width - 600.0).abs() < 0.5);

1947

1948

        // Uniform sequence: one open-ended section.

1949

        let uni = PageSequence::uniform(setup(600.0, 400.0)).width_sections(64);

1950

        assert_eq!(uni.len(), 1);

1951

        assert_eq!(uni[0].page_count, None);

1952

1953

1954

    /// The re-wrap acceptance: content whose height DEPENDS on the page

1955

    /// width (aspect-ratio boxes — no fonts needed) paginates differently

1956

    /// once the tail re-measures at the wider section's width.

1957

    #[test]

1958

    fn sectioned_pagination_rewraps_the_tail_at_the_new_width() {

1959

        use crate::solver3::pagination::PageSequence;

1960

1961

        fn aspect_doc(n: usize) -> StyledDom {

1962

            let children: Vec<Dom> = (0..n).map(|_| Dom::create_div()).collect();

1963

            let mut dom = Dom::create_body().with_children(children.into());

1964

            let css = azul_css::parser2::new_from_str(

1965

                "div { width: 100%; aspect-ratio: 2; background-color: red; }",

1966

1967

.0;

1968

            StyledDom::create(&mut dom, css)

1969

1970

1971

        let loader = PathLoader::new();

1972

        let font_loader = |bytes: std::sync::Arc<rust_fontconfig::FontBytes>, index: usize| {

1973

            loader.load_font_shared(bytes, index)

1974

};

1975

        let mut font_manager: FontManager<TestFont> =

1976

            FontManager::new(FcFontCache::default()).unwrap();

1977

        let rr = RendererResources::default();

1978

        let ic = ImageCache::default();

1979

1980

        // Page 0: 300 wide → divs 150 tall. Later pages: 600 wide → 300 tall.

1981

        let mut seq = PageSequence::uniform(setup(600.0, 400.0));

1982

        seq.overrides.insert(0, setup(300.0, 400.0));

1983

1984

        let sectioned = compute_sectioned_pagination(

1985

            &aspect_doc(8),

1986

            400.0,

1987

            &mut font_manager,

1988

            &rr,

1989

            IdNamespace(0),

1990

            DomId::ROOT_ID,

1991

            font_loader,

1992

            &FakePageConfig::new(),

1993

            &seq,

1994

            &ic,

1995

            time_fn(),

1996

1997

        .expect("sectioned pagination");

1998

1999

        assert_eq!(sectioned.sections.len(), 2, "narrow first page + wide tail");

2000

        assert!((sectioned.sections[1].content_width - 600.0).abs() < 0.5);

2001

2002

        // The same document on a UNIFORM 300-wide sequence for comparison:

2003

        // its divs stay 150 tall everywhere.

2004

        let uniform = compute_sectioned_pagination(

2005

            &aspect_doc(8),

2006

            400.0,

2007

            &mut font_manager,

2008

            &rr,

2009

            IdNamespace(0),

2010

            DomId::ROOT_ID,

2011

            font_loader,

2012

            &FakePageConfig::new(),

2013

            &PageSequence::uniform(setup(300.0, 400.0)),

2014

            &ic,

2015

            time_fn(),

2016

2017

        .expect("uniform pagination");

2018

        assert_eq!(uniform.sections.len(), 1);

2019

2020

        // 600-wide divs are 300 tall → ~1/page; 300-wide divs are 150 tall

2021

        // → ~2/page. If the tail had NOT re-measured at 600, the totals

2022

        // would match — more pages proves the re-wrap happened.

2023

        assert!(

2024

            sectioned.page_count() > uniform.page_count(),

2025

            "sectioned={} uniform={}: the tail must RE-MEASURE at the wide width",

2026

            sectioned.page_count(),

2027

            uniform.page_count()

2028

);

2029

2030

2031

2032

/// A page break mapped to a STRUCTURAL position in the DOM — the keystone of

2033

/// the DOM-materialized-breaks editor architecture: the estimator computes

2034

/// break Y coordinates, the application inserts its break nodes at DOM

2035

/// positions. This type carries both.

2036

#[derive(Debug, Clone, PartialEq)]

2037

pub struct StructuralBreak {

2038

    /// Document-space Y where the page ends (same value as the

2039

    /// corresponding [`PageBreakPosition::y`](crate::solver3::page_breaks::PageBreakPosition)).

2040

    pub y: f32,

2041

    /// Why the break happened.

2042

    pub kind: crate::solver3::page_breaks::BreakKind,

2043

    /// For forced breaks: the node whose break property caused it.

2044

    pub causing_node: Option<NodeId>,

2045

    /// Root-to-node child-index path of the first block-level box at/after

2046

    /// `y` — the position where a break node inserted BEFORE the addressed

2047

    /// node reproduces this page boundary structurally

2048

    /// (`azul_core::dom::Dom` child indices, consumable by

2049

    /// `split_dom_at_path`). `None` when no block-level box sits at/after

2050

    /// `y` (a break in trailing whitespace / past the last block).

2051

    pub path: Option<Vec<u32>>,

2052

    /// Ledger #2 (line-granular option): when the addressed block is an

2053

    /// IFC whose LINE BOXES straddle `y`, the (run, byte) of the first

2054

    /// line that moves to the next page — the app can split the paragraph

2055

    /// text there instead of moving the whole block. `None` = block

2056

    /// boundary (the entire addressed block moves), the v1 contract.

2057

    pub line_start: Option<azul_core::selection::ContentIndex>,

2058

2059

2060

/// Map every break of a [`PaginationInfo`](crate::solver3::page_breaks::PaginationInfo)

2061

/// to its structural DOM position, using the layout tree and positions that

2062

/// [`compute_document_pagination`] left in `cache`.

2063

///

2064

/// Call this immediately after [`compute_document_pagination`] with the SAME

2065

/// `cache` and `styled_dom` — the mapping reads `cache.tree` and

2066

/// `cache.calculated_positions`, which every further layout pass may

2067

/// invalidate. Returns `None` when the cache holds no tree (pagination was

2068

/// never computed, or the cache was cleared).

2069

#[cfg(feature = "text_layout")]

2070

#[must_use]

2071

72

pub fn pagination_to_dom_breaks(

2072

72

    cache: &LayoutCache,

2073

72

    styled_dom: &StyledDom,

2074

72

    pagination: &crate::solver3::page_breaks::PaginationInfo,

2075

72

) -> Option<Vec<StructuralBreak>> {

2076

72

    let tree = cache.tree.as_ref()?;

2077

72

    let positions = &cache.calculated_positions;

2078

    Some(

2079

72

        pagination

2080

72

            .breaks

2081

72

            .iter()

2082

72

            .map(|b| StructuralBreak {

2083

162

                y: b.y,

2084

162

                kind: b.kind,

2085

162

                causing_node: b.causing_node,

2086

162

                path: spine_path_at_y(tree, positions, styled_dom, b.y),

2087

162

                line_start: spine_line_start_at_y(tree, positions, styled_dom, b.y),

2088

162

})

2089

72

            .collect(),

2090

2091

72

2092

2093

/// The DEEPEST block-level box whose border-box vertically CONTAINS `y`

2094

/// (the spine path addresses the first block AT/AFTER `y`; a mid-block

2095

/// break's line lookup needs the box the break lands IN).

2096

162

fn spine_layout_hit_at_y(

2097

162

    tree: &crate::solver3::layout_tree::LayoutTree,

2098

162

    positions: &crate::solver3::PositionVec,

2099

162

    styled_dom: &StyledDom,

2100

162

    y: f32,

2101

162

) -> Option<(usize, f32)> {

2102

162

    let hierarchy = styled_dom.node_hierarchy.as_container();

2103

459

    let depth_of = |mut n: NodeId| -> u32 {

2104

459

        let mut d = 0;

2105

891

        while let Some(p) = hierarchy

2106

891

            .get(n)

2107

891

            .and_then(azul_core::styled_dom::NodeHierarchyItem::parent_id)

2108

432

2109

432

            d += 1;

2110

432

            n = p;

2111

432

2112

459

2113

459

};

2114

162

    let mut best: Option<(u32, usize, f32)> = None;

2115

1053

    for idx in 0..tree.nodes.len() {

2116

1053

        let Some(node) = tree.get(LayoutNodeId::new(idx)) else { continue };

2117

1053

        let Some(dom_id) = node.dom_node_id else { continue };

2118

1053

        if !crate::solver3::layout_tree::is_block_level(styled_dom, dom_id) {

2119

378

            continue;

2120

675

2121

675

        let Some(pos) = crate::solver3::pos_get(positions, idx) else {

2122

            continue;

2123

};

2124

675

        let h = node.used_size.map_or(0.0, |sz| sz.height);

2125

675

        if !(pos.y - 0.5 <= y && y < pos.y + h - 0.5) {

2126

216

            continue;

2127

459

2128

459

        let d = depth_of(dom_id);

2129

459

        if best.as_ref().is_none_or(|(bd, ..)| d > *bd) {

2130

459

            best = Some((d, idx, pos.y));

2131

459

2132

2133

162

    best.map(|(_, idx, top)| (idx, top))

2134

162

2135

2136

/// Ledger #2: the line-granular refinement of [`spine_path_at_y`]. When the

2137

/// block the break lands IN is an IFC with line boxes on both sides of `y`,

2138

/// returns the (run, byte) starting the first line at/after `y` — measured

2139

/// in the block's content box. `None` when the break sits at a block

2140

/// boundary, the block has no inline layout, or every line is below `y`

2141

/// (then the whole block moves — the block-granular contract).

2142

162

#[must_use] pub fn spine_line_start_at_y(

2143

162

    tree: &crate::solver3::layout_tree::LayoutTree,

2144

162

    positions: &crate::solver3::PositionVec,

2145

162

    styled_dom: &StyledDom,

2146

162

    y: f32,

2147

162

) -> Option<azul_core::selection::ContentIndex> {

2148

    use crate::text3::cache::ShapedItem;

2149

162

    let hierarchy = styled_dom.node_hierarchy.as_container();

2150

    // Re-find the spine block the path addresses (same selection rule).

2151

162

    let (layout_idx, node_top) = spine_layout_hit_at_y(tree, positions, styled_dom, y)?;

2152

162

    let node = tree.get(LayoutNodeId::new(layout_idx))?;

2153

162

    let bp = node.box_props.unpack();

2154

162

    let content_top = node_top + bp.padding.top + bp.border.top;

2155

162

    let rel_y = y - content_top;

2156

162

    if rel_y <= 0.5 {

2157

36

        return None; // block-boundary break: whole block moves

2158

126

2159

126

    let layout = tree.get_inline_layout_for_node(layout_idx)?;

2160

    // (d6h) Dense-first: the stored sparse may be the retirement

2161

    // sentinel. LineRecords give the tops in O(lines); the sparse arm

2162

    // remains as the flag-off path and the verify oracle.

2163

126

    if let Some(dense) = tree.get_dense_for_node(layout_idx) {

2164

126

        if !dense.clusters.is_empty() {

2165

126

            let result = spine_line_start_dense(dense, rel_y);

2166

126

            if crate::solver3::layout_tree::dense_text_mode() == 2 {

2167

                let sparse = spine_line_start_sparse(layout, rel_y);

2168

                assert_eq!(

2169

                    result, sparse,

2170

                    "d6h verify: spine_line_start dense vs sparse diverged at rel_y {rel_y}"

2171

);

2172

126

2173

126

            return result;

2174

2175

2176

    spine_line_start_sparse(layout, rel_y)

2177

162

2178

2179

/// The sparse fold of [`spine_line_start_at_y`] — the pre-d6h body,

2180

/// kept as the flag-off path and the verify oracle.

2181

fn spine_line_start_sparse(

2182

    layout: &crate::text3::cache::UnifiedLayout,

2183

    rel_y: f32,

2184

) -> Option<azul_core::selection::ContentIndex> {

2185

    use crate::text3::cache::ShapedItem;

2186

    // The line the break lands ON moves to the next page (a sliced line is

2187

    // atomic; a break AT a line top moves that line). Identify it purely by

2188

    // LINE TOPS — per-item heights are not trustworthy on this path — as

2189

    // the line with the largest top not above the break.

2190

    let mut line_tops: BTreeMap<usize, f32> =

2191

        BTreeMap::new();

2192

    for item in &layout.items {

2193

        let entry = line_tops.entry(item.line_index).or_insert(f32::MAX);

2194

        *entry = entry.min(item.position.y);

2195

2196

    let straddler = line_tops

2197

        .iter()

2198

        .filter(|(_, top)| **top <= rel_y + 0.5)

2199

        .max_by(|a, b| a.1.total_cmp(b.1))

2200

        .map(|(line, _)| *line)?;

2201

    // A first-line hit means the whole block moves: block-granular None.

2202

    if straddler == 0 {

2203

        return None;

2204

2205

    let mut best: Option<azul_core::selection::ContentIndex> = None;

2206

    for item in &layout.items {

2207

        if item.line_index != straddler {

2208

            continue;

2209

2210

        // Clusters carry their identity in `source_cluster_id` (the same

2211

        // GraphemeClusterId the cursor/editing pipeline keys on);

2212

        // `source_content_index` is not populated on the paged shaping

2213

        // path. Non-cluster items fall back to their ContentIndex.

2214

        let src = match &item.item {

2215

            ShapedItem::Cluster(c) => azul_core::selection::ContentIndex {

2216

                run_index: c.source_cluster_id.source_run,

2217

                item_index: c.source_cluster_id.start_byte_in_run,

2218

},

2219

            ShapedItem::CombinedBlock { source, .. }

2220

            | ShapedItem::Object { source, .. }

2221

            | ShapedItem::Tab { source, .. }

2222

            | ShapedItem::Break { source, .. } => *source,

2223

};

2224

        if best

2225

            .as_ref()

2226

            .is_none_or(|s| (src.run_index, src.item_index) < (s.run_index, s.item_index))

2227

2228

            best = Some(src);

2229

2230

2231

    best

2232

2233

2234

/// (d6h) The dense twin of [`spine_line_start_sparse`]: line tops from

2235

/// `LineRecord` in O(lines). A line's sparse "top" is the MIN per-item y

2236

/// — on mixed-size lines that is `shared_baseline - max ascent over the

2237

/// line's runs`, reconstructed here exactly as the expander does.

2238

126

fn spine_line_start_dense(

2239

126

    dense: &crate::text3::dense::DenseText,

2240

126

    rel_y: f32,

2241

126

) -> Option<azul_core::selection::ContentIndex> {

2242

    use crate::text3::dense::DenseText;

2243

7686

    let line_top = |l: &crate::text3::dense::LineRecord| -> f32 {

2244

7686

        let Some(first_run) = dense.run_of(l.clusters.0) else {

2245

            return l.baseline_y;

2246

};

2247

7686

        let base = l.baseline_y + DenseText::resolved_run_ascent(first_run);

2248

7686

        let mut top = f32::MAX;

2249

7686

        let mut ci = l.clusters.0;

2250

15372

        while ci < l.clusters.1 {

2251

7686

            let Some(r) = dense.run_of(ci) else { break };

2252

7686

            top = top.min(base - DenseText::resolved_run_ascent(r));

2253

7686

            ci = r.clusters.end.max(ci + 1);

2254

2255

7686

        if top == f32::MAX { l.baseline_y } else { top }

2256

7686

};

2257

126

    let straddler = dense

2258

126

        .lines

2259

126

        .iter()

2260

3690

        .filter(|l| line_top(l) <= rel_y + 0.5)

2261

1998

        .max_by(|a, b| line_top(a).total_cmp(&line_top(b)))?;

2262

126

    if straddler.source_index == 0 {

2263

72

        return None;

2264

54

2265

54

    let mut best: Option<azul_core::selection::ContentIndex> = None;

2266

1566

    for ci in straddler.clusters.0..straddler.clusters.1 {

2267

1566

        let c = &dense.clusters[ci as usize];

2268

1566

        let run = dense.run_of(ci)?;

2269

1566

        let src = azul_core::selection::ContentIndex {

2270

1566

            run_index: run.source_run,

2271

1566

            item_index: c.start_byte,

2272

1566

};

2273

1566

        if best

2274

1566

            .as_ref()

2275

1566

            .is_none_or(|s| (src.run_index, src.item_index) < (s.run_index, s.item_index))

2276

54

2277

54

            best = Some(src);

2278

1512

2279

2280

54

    best

2281

126

2282

2283

/// One fragmentainer's outcome from [`layout_document_tokenized`].

2284

#[derive(Debug, Clone)]

2285

pub struct TokenizedPage {

2286

    /// Block-size of the content laid INTO this fragmentainer (the root's

2287

    /// fitted used height for this pass).

2288

    pub content_block_size: f32,

2289

    /// The outgoing resume token (`None` = the document finished here).

2290

    pub outgoing: Option<crate::solver3::break_token::BreakToken>,

2291

    /// This page's display list, GENERATED from the fragment pass (never

2292

    /// sliced): only nodes laid on this page have assigned positions —

2293

    /// everything else sits at the unassigned sentinel and is dropped by

2294

    /// `push_item`. Page-local coordinates (the fragmentainer origin is 0).

2295

    pub display_list: DisplayList,

2296

2297

2298

/// K30b part 2 / K30c skeleton: the NG-style page loop. Lays the document

2299

/// out one fragmentainer at a time — page N's outgoing token is page N+1's

2300

/// incoming token; layout re-descends the tree each page, skipping finished

2301

/// subtrees via the token (design doc §4.5). No display lists yet (that is

2302

/// the rest of K30c); the output pins the token algebra: progress,

2303

/// conservation, nested resume.

2304

///

2305

/// # Errors

2306

/// Propagates layout errors; the internal no-progress guard turns the

2307

/// NG infinite-loop class into loop termination instead.

2308

#[allow(clippy::too_many_arguments)]

2309

/// K34 — token convergence: what a previous tokenized run left behind, so

2310

/// an incremental re-pagination can stop as soon as it re-synchronizes with

2311

/// it.

2312

///

2313

/// Tokens are owned value types with reliable `Eq`, so the invariant is

2314

/// exact: **if the token entering page N is unchanged, pages ≥ N are

2315

/// unchanged.** An edit therefore only has to re-lay pages until an

2316

/// outgoing token matches the cached one for that page; everything after

2317

/// is reused verbatim. Typing converges in ≤ 2 pages, which is what makes

2318

/// live repagination affordable on a long document.

2319

#[derive(Debug, Clone, Default)]

2320

pub struct TokenCache {

2321

    /// Per-page outgoing token from the previous run (`None` = the document

2322

    /// ended on that page).

2323

    pub outgoing: Vec<Option<crate::solver3::break_token::BreakToken>>,

2324

    /// The pages themselves, reused verbatim from the convergence point on.

2325

    pub pages: Vec<TokenizedPage>,

2326

2327

2328

/// Outcome of an incremental (convergence-aware) pagination.

2329

#[derive(Debug)]

2330

pub struct IncrementalPagination {

2331

    /// The full page list — freshly laid pages followed by any reused tail.

2332

    pub pages: Vec<TokenizedPage>,

2333

    /// How many pages this run actually laid out. `pages.len() - laid_out`

2334

    /// is what convergence saved.

2335

    pub laid_out: usize,

2336

    /// The page index at which the run re-synchronized with the cache, if it

2337

    /// did (`None` = it ran to the end of the document).

2338

    pub converged_at: Option<usize>,

2339

2340

2341

/// What the shared page loop returns (see `layout_document_tokenized_from`).

2342

struct PageLoopOutcome {

2343

    pages: Vec<TokenizedPage>,

2344

    laid_out: usize,

2345

    converged_at: Option<usize>,

2346

2347

2348

/// The public full-document entry point: lay every page from the start.

2349

#[allow(clippy::too_many_arguments)]

2350

11

pub fn layout_document_tokenized<T, F>(

2351

11

    cache: &mut LayoutCache,

2352

11

    text_cache: &mut TextLayoutCache,

2353

11

    new_dom: &StyledDom,

2354

11

    viewport: LogicalRect,

2355

11

    font_manager: &mut crate::font_traits::FontManager<T>,

2356

11

    debug_messages: &mut Option<Vec<LayoutDebugMessage>>,

2357

11

    image_cache: &azul_core::resources::ImageCache,

2358

11

    get_system_time_fn: azul_core::task::GetSystemTimeCallback,

2359

11

    font_loader: F,

2360

11

    renderer_resources: &RendererResources,

2361

11

    id_namespace: azul_core::resources::IdNamespace,

2362

11

    dom_id: DomId,

2363

11

    page_height: f32,

2364

11

    max_pages: usize,

2365

11

) -> Result<Vec<TokenizedPage>>

2366

11

where

2367

11

    T: ParsedFontTrait + Sync + 'static,

2368

11

    F: Fn(

2369

11

            std::sync::Arc<rust_fontconfig::FontBytes>,

2370

11

            usize,

2371

11

        ) -> std::result::Result<T, crate::text3::cache::LayoutError>

2372

11

        + Copy,

2373

2374

11

    Ok(layout_document_tokenized_from(

2375

11

        cache, text_cache, new_dom, viewport, font_manager, debug_messages,

2376

11

        image_cache, get_system_time_fn, font_loader, renderer_resources,

2377

11

        id_namespace, dom_id, page_height, max_pages, None, None,

2378

)?

2379

    .pages)

2380

11

2381

2382

/// The shared page loop. `start_token` resumes mid-document (K34 incremental

2383

/// re-pagination); `converge_against` lets it stop as soon as it

2384

/// re-synchronizes with a previous run.

2385

#[allow(clippy::too_many_arguments)]

2386

11

fn layout_document_tokenized_from<T, F>(

2387

11

    cache: &mut LayoutCache,

2388

11

    text_cache: &mut TextLayoutCache,

2389

11

    new_dom: &StyledDom,

2390

11

    viewport: LogicalRect,

2391

11

    font_manager: &mut crate::font_traits::FontManager<T>,

2392

11

    debug_messages: &mut Option<Vec<LayoutDebugMessage>>,

2393

11

    image_cache: &azul_core::resources::ImageCache,

2394

11

    get_system_time_fn: azul_core::task::GetSystemTimeCallback,

2395

11

    font_loader: F,

2396

11

    renderer_resources: &RendererResources,

2397

11

    id_namespace: azul_core::resources::IdNamespace,

2398

11

    dom_id: DomId,

2399

11

    page_content_height: f32,

2400

11

    max_pages: usize,

2401

11

    start_token: Option<crate::solver3::break_token::BreakToken>,

2402

11

    converge_against: Option<(&TokenCache, usize)>,

2403

11

) -> Result<PageLoopOutcome>

2404

11

where

2405

11

    T: ParsedFontTrait + Sync + 'static,

2406

11

    F: Fn(

2407

11

        std::sync::Arc<rust_fontconfig::FontBytes>,

2408

11

        usize,

2409

11

    ) -> std::result::Result<T, crate::text3::cache::LayoutError>,

2410

2411

    use crate::solver3::break_token::{token_fingerprint, BreakToken};

2412

11

    let mut laid_out: usize = 0;

2413

11

    let mut converged_at: Option<usize> = None;

2414

    use crate::solver3::cache::{calculate_layout_for_subtree_fragment, ComputeMode};

2415

    use crate::solver3::fc::FragmentainerSpace;

2416

2417

    // 1. Build the tree + shape text once via a CONTINUOUS pass (the page

2418

    // loop re-descends this structure; fonts resolve the same way the

2419

    // paged estimator does).

2420

11

    let mut frag = FragmentationContext::new_continuous(viewport.size.width);

2421

2422

        // Font resolution identical to the paged path.

2423

        use crate::solver3::getters::{

2424

            collect_and_resolve_font_chains_with_registration, collect_font_ids_from_chains,

2425

            compute_fonts_to_load, load_fonts_from_disk,

2426

};

2427

11

        let _p = crate::probe::Probe::span("font_chain_resolve");

2428

        // SKIP THE RESOLVER when this DOM asks for the same font stacks the

2429

        // manager already resolved. `LayoutWindow` has done this since the

2430

        // beginning (window.rs, `font_requirements_unchanged`) via a rolling

2431

        // hash of the compact cache's `prev_font_hashes`; the pagination

2432

        // entry points did not — and worse, called the plain

2433

        // `set_font_chain_cache`, which CLEARS the recorded signature, so

2434

        // even a caller reusing one FontManager re-resolved a 160-family

2435

        // chain on EVERY pagination (measured 8 ms/call, ~8% of a warm one).

2436

11

        let font_stacks_sig = new_dom

2437

11

            .css_property_cache

2438

11

            .ptr

2439

11

            .compact_cache

2440

11

            .as_ref()

2441

11

            .map(|cc| {

2442

11

                let mut h: u64 = 0xcbf2_9ce4_8422_2325;

2443

161

                for &fh in &cc.prev_font_hashes {

2444

150

                    h = h.rotate_left(13) ^ fh;

2445

150

                    h = h.wrapping_mul(0x0100_0000_01b3);

2446

150

2447

11

2448

11

});

2449

11

        let font_requirements_unchanged = font_stacks_sig.is_some()

2450

11

            && font_stacks_sig == font_manager.last_resolved_font_stacks_sig

2451

            && !font_manager.font_chain_cache.is_empty();

2452

2453

11

        if !font_requirements_unchanged {

2454

11

            let _p = crate::probe::Probe::span("font_chain_resolve");

2455

11

            let platform = azul_css::system::Platform::current();

2456

11

            let chains = collect_and_resolve_font_chains_with_registration(

2457

11

                new_dom, &font_manager.fc_cache, font_manager, &platform,

2458

);

2459

11

            let required = collect_font_ids_from_chains(&chains);

2460

11

            let loaded = font_manager.get_loaded_font_ids();

2461

11

            let to_load = compute_fonts_to_load(&required, &loaded);

2462

11

            if !to_load.is_empty() {

2463

11

                let res = load_fonts_from_disk(&to_load, &font_manager.fc_cache, &font_loader);

2464

11

                font_manager.insert_fonts(res.loaded);

2465

11

2466

11

            font_manager

2467

11

                .set_font_chain_cache_with_sig(chains.into_fontconfig_chains(), font_stacks_sig);

2468

2469

2470

11

    compute_layout_with_fragmentation(

2471

11

        cache,

2472

11

        text_cache,

2473

11

        &mut frag,

2474

11

        new_dom,

2475

11

        viewport,

2476

11

        font_manager,

2477

11

        debug_messages,

2478

11

        image_cache,

2479

11

        get_system_time_fn,

2480

        false,

2481

)?;

2482

2483

    // 2. The page loop.

2484

11

    let mut pages: Vec<TokenizedPage> = Vec::new();

2485

11

    let mut incoming: Option<BreakToken> = start_token;

2486

27

    for page_idx in 0..max_pages {

2487

27

        let resume = match incoming.as_ref() {

2488

11

            None => None,

2489

16

            Some(BreakToken::Block(b)) => Some(b),

2490

            // The ROOT is a block box; an inline token cannot reach here.

2491

            Some(BreakToken::Inline(_)) => None,

2492

};

2493

27

        let space = FragmentainerSpace {

2494

27

            remaining_block_extent: page_content_height,

2495

27

            next_fragmentainer_extent: page_content_height,

2496

27

            is_first: page_idx == 0 && incoming.is_none(),

2497

27

            resume,

2498

};

2499

2500

27

        let tree = cache.tree.as_mut().ok_or(LayoutError::InvalidTree)?;

2501

27

        let mut counter_values = cache.counters.clone();

2502

27

        let empty_text_selections: BTreeMap<DomId, TextSelection> = BTreeMap::new();

2503

27

        let mut ctx = LayoutContext {

2504

27

            style_cache: Default::default(),

2505

27

            scrollbar_style_cache: core::cell::RefCell::new(std::collections::HashMap::new()),

2506

27

            styled_dom: new_dom,

2507

27

            font_manager: &*font_manager,

2508

27

            text_selections: &empty_text_selections,

2509

27

            debug_messages,

2510

27

            counters: &mut counter_values,

2511

27

            viewport_size: viewport.size,

2512

27

            fragmentation_context: None,

2513

27

            reflowed_ifcs: std::collections::BTreeSet::new(),

2514

27

            cursor_is_visible: false,

2515

27

            cursor_locations: Vec::new(),

2516

27

            preedit_text: None,

2517

27

            cache_map: std::mem::take(&mut cache.cache_map),

2518

27

            image_cache,

2519

27

            content_overlay: None,

2520

27

            system_style: None,

2521

27

            get_system_time_fn,

2522

27

};

2523

2524

27

        let mut outgoing: Option<BreakToken> = None;

2525

        // Positions pre-filled with the UNASSIGNED sentinel: only nodes the

2526

        // fragment pass actually lays on THIS page receive positions; the

2527

        // display-list builder drops everything else (its existing

2528

        // unassigned-position guard) — pages are generated, never sliced.

2529

27

        let node_count = tree.nodes.len();

2530

27

        let mut page_positions: crate::solver3::PositionVec =

2531

27

            alloc::vec![crate::solver3::POSITION_UNSET; node_count];

2532

27

        let mut tmp_scrollbars = false;

2533

27

        let mut tmp_floats = std::collections::HashMap::new();

2534

27

        let result = calculate_layout_for_subtree_fragment(

2535

27

            &mut ctx,

2536

27

            tree,

2537

27

            text_cache,

2538

            0, // the root layout node

2539

27

            LogicalPosition::zero(),

2540

27

            viewport.size,

2541

27

            &mut page_positions,

2542

27

            &mut tmp_scrollbars,

2543

27

            &mut tmp_floats,

2544

27

            ComputeMode::PerformLayout,

2545

27

            Some(space),

2546

27

            Some(&mut outgoing),

2547

);

2548

27

        result?;

2549

2550

        // The ROOT box itself sits at the fragmentainer origin (its

2551

        // children got positions from Pass 2; the root's own position is

2552

        // the caller's job on the normal path).

2553

27

        crate::solver3::pos_set(&mut page_positions, 0, LogicalPosition::zero());

2554

2555

        // Generate THIS page's display list from the fragment positions.

2556

27

        let display_list = {

2557

27

            let tree_ref: &_ = tree;

2558

27

            crate::solver3::display_list::generate_display_list(

2559

27

                &mut ctx,

2560

27

                tree_ref,

2561

27

                &page_positions,

2562

27

                &BTreeMap::new(),

2563

27

                &cache.scroll_ids,

2564

27

                None,

2565

27

                renderer_resources,

2566

27

                id_namespace,

2567

27

                dom_id,

2568

)?

2569

};

2570

27

        cache.cache_map = std::mem::take(&mut ctx.cache_map);

2571

2572

27

        let content = cache

2573

27

            .tree

2574

27

            .as_ref()

2575

27

            .and_then(|t| t.get(LayoutNodeId::new(0)))

2576

27

            .and_then(|n| n.used_size)

2577

27

            .map_or(0.0, |sz| sz.height);

2578

2579

        // PROGRESS GUARD (the NG infinite-loop class): an outgoing token

2580

        // identical to the incoming one means the page consumed nothing.

2581

27

        let stalled = match (&incoming, &outgoing) {

2582

6

            (Some(a), Some(b)) => {

2583

6

                token_fingerprint(a) == token_fingerprint(b) && a == b

2584

2585

21

            _ => false,

2586

};

2587

27

        pages.push(TokenizedPage {

2588

27

            content_block_size: content,

2589

27

            outgoing: outgoing.clone(),

2590

27

            display_list,

2591

27

});

2592

27

        laid_out += 1;

2593

27

        if stalled || outgoing.is_none() {

2594

11

            break;

2595

16

2596

2597

        // K34 CONVERGENCE. Tokens are value types with reliable `Eq`: if the

2598

        // token leaving this page equals the one that left the SAME page

2599

        // last time, every later page receives an identical input and is

2600

        // therefore identical. Splice the cached tail in and stop — this is

2601

        // what turns "repaginate the document" into "repaginate two pages".

2602

16

        if let Some((cached, base)) = converge_against {

2603

            let abs_page = base + page_idx;

2604

            if let Some(cached_outgoing) = cached.outgoing.get(abs_page) {

2605

                let same = match (cached_outgoing, &outgoing) {

2606

                    (Some(a), Some(b)) => {

2607

                        token_fingerprint(a) == token_fingerprint(b) && a == b

2608

2609

                    (None, None) => true,

2610

                    _ => false,

2611

};

2612

                if same && abs_page + 1 < cached.pages.len() {

2613

                    pages.extend(cached.pages[abs_page + 1..].iter().cloned());

2614

                    converged_at = Some(abs_page);

2615

                    break;

2616

2617

2618

16

2619

2620

16

        incoming = outgoing;

2621

2622

11

    Ok(PageLoopOutcome { pages, laid_out, converged_at })

2623

11

2624

2625

/// K34: re-paginate from `first_dirty_page`, stopping as soon as the run

2626

/// re-synchronizes with `cache`.

2627

///

2628

/// The caller supplies the page the edit dirtied (`page_of_y` on the

2629

/// chokepoint's dirty extent) and the previous run's [`TokenCache`]. Pages

2630

/// before `first_dirty_page` are reused untouched — their incoming tokens

2631

/// predate the edit and are therefore still valid — and the loop resumes

2632

/// from that page's cached incoming token. After each freshly laid page the

2633

/// outgoing token is compared against the cached one for the same index: on

2634

/// equality every later page is spliced in verbatim and the run stops.

2635

///

2636

/// Falls back to a full run whenever the cache cannot be trusted (empty,

2637

/// or `first_dirty_page` beyond it), so a caller can always call this.

2638

///

2639

/// # Errors

2640

///

2641

/// Propagates layout failures from the underlying page loop.

2642

#[allow(clippy::too_many_arguments)]

2643

pub fn layout_document_tokenized_incremental<T, F>(

2644

    cache: &mut LayoutCache,

2645

    text_cache: &mut TextLayoutCache,

2646

    new_dom: &StyledDom,

2647

    viewport: LogicalRect,

2648

    font_manager: &mut crate::font_traits::FontManager<T>,

2649

    debug_messages: &mut Option<Vec<LayoutDebugMessage>>,

2650

    image_cache: &azul_core::resources::ImageCache,

2651

    get_system_time_fn: azul_core::task::GetSystemTimeCallback,

2652

    font_loader: F,

2653

    renderer_resources: &RendererResources,

2654

    id_namespace: azul_core::resources::IdNamespace,

2655

    dom_id: DomId,

2656

    page_height: f32,

2657

    max_pages: usize,

2658

    token_cache: &TokenCache,

2659

    first_dirty_page: usize,

2660

) -> Result<IncrementalPagination>

2661

where

2662

    T: ParsedFontTrait + Sync + 'static,

2663

    F: Fn(

2664

            std::sync::Arc<rust_fontconfig::FontBytes>,

2665

            usize,

2666

        ) -> std::result::Result<T, crate::text3::cache::LayoutError>

2667

        + Copy,

2668

2669

    // A full run whenever the cache cannot help.

2670

    let usable = !token_cache.pages.is_empty()

2671

        && token_cache.outgoing.len() == token_cache.pages.len()

2672

        && first_dirty_page < token_cache.pages.len();

2673

    if !usable {

2674

        let pages = layout_document_tokenized(

2675

            cache, text_cache, new_dom, viewport, font_manager, debug_messages,

2676

            image_cache, get_system_time_fn, font_loader, renderer_resources,

2677

            id_namespace, dom_id, page_height, max_pages,

2678

)?;

2679

        let laid_out = pages.len();

2680

        return Ok(IncrementalPagination { pages, laid_out, converged_at: None });

2681

2682

2683

    // Pages before the dirty one are untouched by definition.

2684

    let mut pages: Vec<TokenizedPage> = token_cache.pages[..first_dirty_page].to_vec();

2685

    // Resume from the token that ENTERED the dirty page: the previous

2686

    // page's outgoing, which predates the edit.

2687

    let resume_token = if first_dirty_page == 0 {

2688

        None

2689

    } else {

2690

        token_cache.outgoing[first_dirty_page - 1].clone()

2691

};

2692

2693

    let tail = layout_document_tokenized_from(

2694

        cache, text_cache, new_dom, viewport, font_manager, debug_messages,

2695

        image_cache, get_system_time_fn, font_loader, renderer_resources,

2696

        id_namespace, dom_id, page_height,

2697

        max_pages.saturating_sub(first_dirty_page),

2698

        resume_token,

2699

        Some((token_cache, first_dirty_page)),

2700

)?;

2701

2702

    let laid_out = tail.laid_out;

2703

    let converged_at = tail.converged_at;

2704

    pages.extend(tail.pages);

2705

    Ok(IncrementalPagination { pages, laid_out, converged_at })

2706

2707

2708

/// The per-page delta of a re-estimation, for the editor's lazy re-break

2709

/// loop: pages whose breaks are bit-for-bit unchanged keep their DOM

2710

/// subtrees untouched; patching starts at `first_changed_page`.

2711

#[derive(Debug, Clone, Copy, PartialEq, Eq)]

2712

pub struct BreaksDelta {

2713

    /// Breaks (compared by exact `y` AND `kind`) identical to the previous

2714

    /// estimate up to this index. On the first estimate this is 0.

2715

    pub unchanged_prefix_len: usize,

2716

    /// The first page whose boundary moved — equal to

2717

    /// `unchanged_prefix_len` (page N ends at break N).

2718

    pub first_changed_page: usize,

2719

    /// Whether the total page count changed.

2720

    pub page_count_changed: bool,

2721

2722

2723

/// Owns the caches an incremental pagination loop needs

2724

/// ([`crate::solver3::cache::LayoutCache`] + text cache + the previous

2725

/// estimate) so an embedder holds ONE session object instead of wiring

2726

/// solver internals (AZUL-STILL-TODO B7).

2727

///

2728

/// ```text

2729

/// changeset -> app model -> session.re_estimate(new_dom, ...) -> BreaksDelta

2730

///           -> patch own DOM only from first_changed_page on

2731

///           -> session.dom_breaks(new_dom) for the structural positions

2732

/// ```

2733

// Holds the layout + text caches, neither of which is `Debug` (they are

2734

// large, self-referential-ish caches whose contents are meaningless in a

2735

// debug print). Deriving would force `Debug` onto both cache types.

2736

#[allow(missing_debug_implementations)]

2737

#[cfg(feature = "text_layout")]

2738

pub struct PaginationSession {

2739

    pub layout_cache: LayoutCache,

2740

    pub text_cache: TextLayoutCache,

2741

    pub previous: Option<crate::solver3::page_breaks::PaginationInfo>,

2742

2743

2744

#[cfg(feature = "text_layout")]

2745

impl Default for PaginationSession {

2746

    fn default() -> Self {

2747

        Self::new()

2748

2749

2750

2751

#[cfg(feature = "text_layout")]

2752

impl PaginationSession {

2753

    #[must_use]

2754

18

    pub fn new() -> Self {

2755

18

        Self {

2756

18

            layout_cache: LayoutCache::default(),

2757

18

            text_cache: TextLayoutCache::new(),

2758

18

            previous: None,

2759

18

2760

18

2761

2762

    /// Re-estimate pagination for (a new generation of) the document and

2763

    /// report which pages kept their boundaries. Layout reuses this

2764

    /// session's caches, so an unchanged prefix is cheap by construction.

2765

    #[allow(clippy::too_many_arguments)] // mirrors compute_document_pagination's surface

2766

4

    pub fn re_estimate<T, F>(

2767

4

        &mut self,

2768

4

        styled_dom: &StyledDom,

2769

4

        viewport: LogicalRect,

2770

4

        font_manager: &mut crate::font_traits::FontManager<T>,

2771

4

        scroll_offsets: &BTreeMap<NodeId, ScrollPosition>,

2772

4

        debug_messages: &mut Option<Vec<LayoutDebugMessage>>,

2773

4

        gpu_value_cache: Option<&azul_core::gpu::GpuValueCache>,

2774

4

        renderer_resources: &RendererResources,

2775

4

        id_namespace: azul_core::resources::IdNamespace,

2776

4

        dom_id: DomId,

2777

4

        font_loader: F,

2778

4

        page_config: FakePageConfig,

2779

4

        image_cache: &azul_core::resources::ImageCache,

2780

4

        get_system_time_fn: azul_core::task::GetSystemTimeCallback,

2781

4

    ) -> Result<BreaksDelta>

2782

4

    where

2783

4

        T: ParsedFontTrait + Sync + 'static,

2784

4

        F: Fn(

2785

4

            std::sync::Arc<rust_fontconfig::FontBytes>,

2786

4

            usize,

2787

4

        ) -> std::result::Result<T, crate::text3::cache::LayoutError>,

2788

2789

4

        let fragmentation_context = FragmentationContext::new_paged(viewport.size);

2790

4

        let info = compute_document_pagination(

2791

4

            &mut self.layout_cache,

2792

4

            &mut self.text_cache,

2793

4

            fragmentation_context,

2794

4

            styled_dom,

2795

4

            viewport,

2796

4

            font_manager,

2797

4

            scroll_offsets,

2798

4

            debug_messages,

2799

4

            gpu_value_cache,

2800

4

            renderer_resources,

2801

4

            id_namespace,

2802

4

            dom_id,

2803

4

            font_loader,

2804

4

            page_config,

2805

4

            image_cache,

2806

4

            get_system_time_fn,

2807

)?;

2808

2809

4

        let unchanged_prefix_len = match &self.previous {

2810

2

            None => 0,

2811

2

            Some(prev) => prev

2812

2

                .breaks

2813

2

                .iter()

2814

2

                .zip(info.breaks.iter())

2815

                // The reuse contract: unchanged breaks are bit-for-bit equal

2816

                // (recompute_page_breaks_from), so exact comparison is right —

2817

                // an epsilon would hide genuinely moved boundaries.

2818

4

                .take_while(|(a, b)| a.y.to_bits() == b.y.to_bits() && a.kind == b.kind)

2819

2

                .count(),

2820

};

2821

4

        let page_count_changed = self

2822

4

            .previous

2823

4

            .as_ref()

2824

4

            .is_none_or(|prev| prev.page_count != info.page_count);

2825

4

        self.previous = Some(info);

2826

4

        Ok(BreaksDelta {

2827

4

            unchanged_prefix_len,

2828

4

            first_changed_page: unchanged_prefix_len,

2829

4

            page_count_changed,

2830

4

})

2831

4

2832

2833

    /// The latest estimate (after at least one [`Self::re_estimate`]).

2834

    #[must_use]

2835

4

    pub const fn info(&self) -> Option<&crate::solver3::page_breaks::PaginationInfo> {

2836

4

        self.previous.as_ref()

2837

4

2838

2839

    /// Structural DOM positions for the latest estimate — see

2840

    /// [`pagination_to_dom_breaks`]. Call with the SAME document that was

2841

    /// last re-estimated.

2842

    #[must_use]

2843

18

    pub fn dom_breaks(&self, styled_dom: &StyledDom) -> Option<Vec<StructuralBreak>> {

2844

18

        let info = self.previous.as_ref()?;

2845

18

        pagination_to_dom_breaks(&self.layout_cache, styled_dom, info)

2846

18

2847