Grcov report - headless.rs

1

//! Headless backend for CPU-only rendering without a display server.

2

//!

3

//! This module provides the resource management and rendering pipeline for

4

//! running Azul applications without any platform windowing APIs. It works

5

//! in combination with `HeadlessWindow` (in `dll/src/desktop/shell2/headless/`) which

6

//! provides the `PlatformWindow` trait implementation.

7

//!

8

//! # Architecture

9

//!

10

//! The headless path replaces the WebRender GPU pipeline with `cpurender`:

11

//! `LayoutWindow → solver3 DisplayList → cpurender → PNG/Pixmap`. Compared to the

12

//! GPU path there is no GL context, `webrender::Renderer`, or `RenderApi`; fonts

13

//! and images are managed by `FontManager`/`ImageCache` and read directly by

14

//! cpurender (no GPU texture atlas or upload), hit testing uses the layout-side

15

//! `CpuHitTester` instead of WebRender's `AsyncHitTester`, and present/swap is a

16

//! no-op.

17

//!

18

//! Activated with `AZUL_HEADLESS=1` (optionally `AZ_DEBUG=1` for the debug server).

19

20

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

21

use std::collections::BTreeMap;

22

23

use azul_core::{

24

    dom::{DomId, DomNodeId, NodeId},

25

    geom::{LogicalPosition, LogicalRect, LogicalSize},

26

    hit_test::FullHitTest,

27

    styled_dom::StyledDom,

28

};

29

30

use crate::solver3::{getters::{get_overflow_x, get_overflow_y}, layout_tree::LayoutNodeHot, PositionVec};

31

use crate::window::DomLayoutResult;

32

33

/// Large finite half-extent used in place of `f32::INFINITY` for clip axes that

34

/// are not constrained by any ancestor. Keeping it finite avoids `NaN` in

35

/// `point_in_rect` (`origin + size` would be `inf - inf = NaN`) while staying

36

/// far outside any realistic logical-pixel coordinate.

37

const CLIP_UNBOUNDED: f32 = 1.0e7;

38

39

/// CPU-based hit tester that works without `WebRender`.

40

///

41

/// In the GPU path, hit testing is done by `AsyncHitTester` which queries

42

/// `WebRender`'s spatial tree. In headless mode, we do hit testing directly

43

/// against the layout results (positioned rectangles).

44

///

45

/// This is actually simpler and faster than the `WebRender` path, since we

46

/// don't need to go through the compositor's spatial tree — we just walk

47

/// the layout result nodes and check point-in-rect.

48

#[derive(Debug)]

49

pub struct CpuHitTester {

50

    /// Cached hit test results from the last layout.

51

    /// Maps `DomId` -> list of (`NodeId`, positioned rect) sorted by paint order.

52

    node_rects: BTreeMap<DomId, Vec<HitTestEntry>>,

53

    /// Interned ancestor chains (scroll frames + reference frames). Index 0

54

    /// is always the empty chain. Entry / clip `chain` values index into

55

    /// this. A node's on-screen position is

56

    /// `T_total(static_pos − scroll_total)` — the same rule

57

    /// `cpurender::raster` paints with (accumulated scroll subtraction, then

58

    /// the composed reference-frame transform), so pixels and pointer

59

    /// targets cannot disagree.

60

    chains: Vec<Vec<HitChainLink>>,

61

    /// Every node that got a `PushScrollFrame` (from

62

    /// `DomLayoutResult::scroll_ids`, the same set the display list uses),

63

    /// translated into window space, with the chain of its STRICT scroll

64

    /// ancestors (a container's own viewport box does not move when it

65

    /// scrolls — only its content does).

66

    scroll_containers: Vec<ScrollContainerEntry>,

67

    /// `VirtualView` child-DOM placements in window space (static coords).

68

    dom_placements: BTreeMap<DomId, LogicalRect>,

69

70

71

/// A single entry in the CPU hit test acceleration structure.

72

#[derive(Debug, Clone)]

73

struct HitTestEntry {

74

    /// The DOM node that this entry corresponds to.

75

    node_id: NodeId,

76

    /// Static (unscrolled) position and size of this node in logical pixels,

77

    /// window space (`VirtualView` placement already applied).

78

    rect: LogicalRect,

79

    /// Ancestor scroll frames whose offsets shift this node on screen

80

    /// (index into [`CpuHitTester::chains`]).

81

    chain: u32,

82

    /// Clip boxes from `overflow`-clipping ancestors and the `VirtualView`

83

    /// composite bounds. Each clip carries the chain of ITS owner's strict

84

    /// scroll ancestors — a clip box inside a scrolled frame moves with that

85

    /// frame, while the clipping container's own scroll does not move its

86

    /// viewport. Axis-only clips (`overflow-x`/`overflow-y` independent) are

87

    /// stored with the unclipped axis widened to [`CLIP_UNBOUNDED`].

88

    clips: Vec<(LogicalRect, u32)>,

89

    /// Whether this node is pointer-events: none

90

    pointer_events_none: bool,

91

92

93

/// A scroll container (`PushScrollFrame` owner) for wheel-target resolution.

94

#[derive(Debug, Clone)]

95

struct ScrollContainerEntry {

96

    dom_id: DomId,

97

    node_id: NodeId,

98

    /// Index of this node in its DOM's layout tree (for content-size lookup).

99

    layout_idx: LayoutNodeId,

100

    scroll_id: u64,

101

    /// Static viewport box, window space (placement-translated).

102

    rect: LogicalRect,

103

    /// Chain of STRICT scroll ancestors (index into [`CpuHitTester::chains`]).

104

    chain: u32,

105

106

107

/// One link in a node's ancestor chain: something between the node and the

108

/// window root that moves the node's on-screen position at runtime.

109

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

110

pub enum HitChainLink {

111

    /// An ancestor scroll frame — shifts content by the CURRENT scroll

112

    /// offset (`ScrollManager::get_current_offset`), painted as

113

    /// `pos - offset`.

114

    Scroll(DomId, NodeId),

115

    /// An ancestor wrapped in a `PushReferenceFrame` (CSS transform / drag /

116

    /// animation) — the CURRENT matrix lives in the GPU value cache

117

    /// (`css_current_transform_values`), the same source the CPU raster

118

    /// reads at paint time.

119

    Transform(DomId, NodeId),

120

121

122

/// Minimal 2D affine mirroring `agg_rust::trans_affine::TransAffine`.

123

///

124

/// Row-vector convention: `x' = x·sx + y·shx + tx; y' = x·shy + y·sy + ty`.

125

/// Local copy because `agg-rust` is optional (svg/cpurender features) and

126

/// hit-testing must exist in every configuration. The multiply/invert bodies

127

/// are transcribed from agg so composition matches the raster EXACTLY.

128

#[derive(Debug, Clone, Copy)]

129

pub struct ScreenMapAffine {

130

    pub sx: f32,

131

    pub shy: f32,

132

    pub shx: f32,

133

    pub sy: f32,

134

    pub tx: f32,

135

    pub ty: f32,

136

137

138

impl ScreenMapAffine {

139

    pub const IDENTITY: Self = Self {

140

        sx: 1.0,

141

        shy: 0.0,

142

        shx: 0.0,

143

        sy: 1.0,

144

        tx: 0.0,

145

        ty: 0.0,

146

};

147

148

    /// The 2D-affine slice of a `ComputedTransform3D`, exactly the elements

149

    /// the CPU raster feeds `TransAffine::new_custom`

150

    /// (`m[0][0], m[0][1], m[1][0], m[1][1], m[3][0], m[3][1]`).

151

6

    #[must_use] pub const fn from_transform_3d(t: &azul_core::transform::ComputedTransform3D) -> Self {

152

6

        Self {

153

6

            sx: t.m[0][0],

154

6

            shy: t.m[0][1],

155

6

            shx: t.m[1][0],

156

6

            sy: t.m[1][1],

157

6

            tx: t.m[3][0],

158

6

            ty: t.m[3][1],

159

6

160

6

161

162

    /// `self = self · m` (agg `multiply`).

163

6

    pub fn multiply(&mut self, m: &Self) {

164

6

        let t0 = self.sx.mul_add(m.sx, self.shy * m.shx);

165

6

        let t2 = self.shx.mul_add(m.sx, self.sy * m.shx);

166

6

        let t4 = self.tx.mul_add(m.sx, self.ty * m.shx) + m.tx;

167

6

        self.shy = self.sx.mul_add(m.shy, self.shy * m.sy);

168

6

        self.sy = self.shx.mul_add(m.shy, self.sy * m.sy);

169

6

        self.ty = self.tx.mul_add(m.shy, self.ty * m.sy) + m.ty;

170

6

        self.sx = t0;

171

6

        self.shx = t2;

172

6

        self.tx = t4;

173

6

174

175

    /// `self = m · self` (agg `premultiply`) — the raster's per-push step is

176

    /// `composed = tf; composed.premultiply(&current)`.

177

6

    pub fn premultiply(&mut self, m: &Self) {

178

6

        let mut t = *m;

179

6

        t.multiply(self);

180

6

        *self = t;

181

6

182

183

    /// In-place inverse (agg `invert`). Degenerate matrices (determinant 0)

184

    /// leave a non-finite result; callers treat non-finite mapped points as

185

    /// misses, which matches "a zero-scale transform is unclickable".

186

6

    pub fn invert(&mut self) {

187

6

        let d = 1.0 / self.sx.mul_add(self.sy, -(self.shy * self.shx));

188

6

        let t0 = self.sy * d;

189

6

        self.sy = self.sx * d;

190

6

        self.shy = -self.shy * d;

191

6

        self.shx = -self.shx * d;

192

6

        let t4 = (-self.tx).mul_add(t0, -(self.ty * self.shx));

193

6

        self.ty = (-self.tx).mul_add(self.shy, -(self.ty * self.sy));

194

6

        self.sx = t0;

195

6

        self.tx = t4;

196

6

197

198

6

    #[must_use] pub fn apply(&self, p: LogicalPosition) -> LogicalPosition {

199

6

        LogicalPosition {

200

6

            x: p.x.mul_add(self.sx, p.y * self.shx) + self.tx,

201

6

            y: p.x.mul_add(self.shy, p.y * self.sy) + self.ty,

202

6

203

6

204

205

    #[allow(clippy::float_cmp)] // exact equality is correct here: identity is a fast-path gate; a near-identity matrix must still be applied

206

    #[must_use] pub fn is_identity(&self) -> bool {

207

        self.sx == 1.0

208

            && self.shy == 0.0

209

            && self.shx == 0.0

210

            && self.sy == 1.0

211

            && self.tx == 0.0

212

            && self.ty == 0.0

213

214

215

216

/// A chain resolved against the CURRENT scroll offsets and transform values.

217

///

218

/// The CPU raster paints `screen = T_total(pos − scroll_total)` — one

219

/// accumulated scroll translation and one composed transform stack, in that

220

/// order. The inverse mapping used for hit-testing is therefore

221

/// `local = T_total⁻¹(screen) + scroll_total`.

222

#[derive(Debug, Clone, Copy)]

223

struct ResolvedChain {

224

    scroll: LogicalPosition,

225

    /// FORWARD composed transform (identity when the chain has none).

226

    forward: ScreenMapAffine,

227

    has_transform: bool,

228

229

230

impl ResolvedChain {

231

237

    fn map_screen_to_local(&self, p: LogicalPosition) -> LogicalPosition {

232

237

        let p = if self.has_transform {

233

6

            let mut inv = self.forward;

234

6

            inv.invert();

235

6

            inv.apply(p)

236

        } else {

237

231

238

};

239

237

        LogicalPosition {

240

237

            x: p.x + self.scroll.x,

241

237

            y: p.y + self.scroll.y,

242

237

243

237

244

245

756

    fn map_local_to_screen(&self, p: LogicalPosition) -> LogicalPosition {

246

756

        let shifted = LogicalPosition {

247

756

            x: p.x - self.scroll.x,

248

756

            y: p.y - self.scroll.y,

249

756

};

250

756

        if self.has_transform {

251

            self.forward.apply(shifted)

252

        } else {

253

756

            shifted

254

255

756

256

257

258

426

fn resolve_chain(

259

426

    chain: &[HitChainLink],

260

426

    resolve_scroll: &dyn Fn(DomId, NodeId) -> Option<LogicalPosition>,

261

426

    resolve_transform: &dyn Fn(DomId, NodeId) -> Option<azul_core::transform::ComputedTransform3D>,

262

426

) -> ResolvedChain {

263

426

    let mut scroll = LogicalPosition::zero();

264

426

    let mut forward = ScreenMapAffine::IDENTITY;

265

426

    let mut has_transform = false;

266

870

    for link in chain {

267

444

        match link {

268

438

            HitChainLink::Scroll(d, n) => {

269

438

                if let Some(o) = resolve_scroll(*d, *n) {

270

6

                    scroll.x += o.x;

271

6

                    scroll.y += o.y;

272

438

273

274

6

            HitChainLink::Transform(d, n) => {

275

6

                if let Some(t) = resolve_transform(*d, *n) {

276

6

                    // Mirror the raster's per-push composition:

277

6

                    // composed = tf.premultiply(current)

278

6

                    let mut tf = ScreenMapAffine::from_transform_3d(&t);

279

6

                    tf.premultiply(&forward);

280

6

                    forward = tf;

281

6

                    has_transform = true;

282

6

283

284

285

286

426

    ResolvedChain {

287

426

        scroll,

288

426

        forward,

289

426

        has_transform,

290

426

291

426

292

293

/// Map a node's STATIC rect to its ON-SCREEN axis-aligned bounds.

294

///

295

/// Walks the node's ancestors, accumulates scroll offsets and reference-frame

296

/// transforms, and applies the raster's forward rule

297

/// `screen = T_total(corner − scroll_total)` to all four corners (result is

298

/// their AABB).

299

///

300

/// This is THE shared answer to "where is this node on screen right now" —

301

/// menu positioning (`LayoutWindow::get_node_hit_test_bounds`) and the a11y

302

/// snapshot both go through it, so what a screen reader is told and where a

303

/// context menu opens can never disagree with painted pixels.

304

///

305

/// Transform membership is decided by `resolve_transform` returning `Some`

306

/// — pass the same GPU-cache lookup the raster paints from.

307

639

pub fn node_rect_to_screen(

308

639

    layout_result: &DomLayoutResult,

309

639

    dom_id: DomId,

310

639

    layout_idx: usize,

311

639

    rect: LogicalRect,

312

639

    resolve_scroll: &dyn Fn(DomId, NodeId) -> Option<LogicalPosition>,

313

639

    resolve_transform: &dyn Fn(DomId, NodeId) -> Option<azul_core::transform::ComputedTransform3D>,

314

639

) -> LogicalRect {

315

639

    let nodes = &layout_result.layout_tree.nodes;

316

317

    // Collect links walking child→root; reversing yields outermost-first

318

    // with, per ancestor, Transform before Scroll (the builder nests the

319

    // reference frame OUTSIDE the scroll frame).

320

639

    let mut links_rev: Vec<HitChainLink> = Vec::new();

321

639

    let mut cur = nodes.get(layout_idx).and_then(|n| n.parent);

322

639

    let mut guard = 0usize;

323

4491

    while let Some(anc) = cur {

324

3852

        guard += 1;

325

3852

        if guard > nodes.len() {

326

            break;

327

3852

328

3852

        let Some(anc_node) = nodes.get(anc) else { break };

329

3852

        if let Some(anid) = anc_node.dom_node_id {

330

3852

            if layout_result.scroll_ids.contains_key(&LayoutNodeId::new(anc)) {

331

333

                links_rev.push(HitChainLink::Scroll(dom_id, anid));

332

3519

333

3852

            if resolve_transform(dom_id, anid).is_some() {

334

                links_rev.push(HitChainLink::Transform(dom_id, anid));

335

3852

336

337

3852

        cur = anc_node.parent;

338

339

639

    if links_rev.is_empty() {

340

450

        return rect;

341

189

342

189

    let chain: Vec<HitChainLink> = links_rev.into_iter().rev().collect();

343

189

    let resolved = resolve_chain(&chain, resolve_scroll, resolve_transform);

344

345

189

    let corners = [

346

189

        rect.origin,

347

189

        LogicalPosition {

348

189

            x: rect.origin.x + rect.size.width,

349

189

            y: rect.origin.y,

350

189

},

351

189

        LogicalPosition {

352

189

            x: rect.origin.x,

353

189

            y: rect.origin.y + rect.size.height,

354

189

},

355

189

        LogicalPosition {

356

189

            x: rect.origin.x + rect.size.width,

357

189

            y: rect.origin.y + rect.size.height,

358

189

},

359

189

];

360

189

    let mut min_x = f32::INFINITY;

361

189

    let mut min_y = f32::INFINITY;

362

189

    let mut max_x = f32::NEG_INFINITY;

363

189

    let mut max_y = f32::NEG_INFINITY;

364

945

    for c in corners {

365

756

        let s = resolved.map_local_to_screen(c);

366

756

        min_x = min_x.min(s.x);

367

756

        min_y = min_y.min(s.y);

368

756

        max_x = max_x.max(s.x);

369

756

        max_y = max_y.max(s.y);

370

756

371

189

    if !(min_x.is_finite() && min_y.is_finite() && max_x.is_finite() && max_y.is_finite()) {

372

        return rect;

373

189

374

189

    LogicalRect {

375

189

        origin: LogicalPosition { x: min_x, y: min_y },

376

189

        size: LogicalSize {

377

189

            width: (max_x - min_x).max(0.0),

378

189

            height: (max_y - min_y).max(0.0),

379

189

},

380

189

381

639

382

383

/// Intern a chain into the table, returning its index.

384

2107

fn intern_chain(

385

2107

    chains: &mut Vec<Vec<HitChainLink>>,

386

2107

    lookup: &mut std::collections::HashMap<Vec<HitChainLink>, u32>,

387

2107

    v: Vec<HitChainLink>,

388

2107

) -> u32 {

389

2107

    if let Some(&i) = lookup.get(&v) {

390

1875

        return i;

391

232

392

232

    let i = u32::try_from(chains.len()).unwrap_or(u32::MAX);

393

232

    chains.push(v.clone());

394

232

    lookup.insert(v, i);

395

232

396

2107

397

398

impl Default for CpuHitTester {

399

1

    fn default() -> Self {

400

1

        Self::new()

401

1

402

403

404

/// Resolve each layout node's ancestor chain index into `chains`.

405

///

406

/// `chain(n) = chain(parent) (+ parent's links)` — an ancestor shifts its

407

/// CONTENT, not itself. Scroll membership comes from `scroll_ids` (the exact

408

/// set the display-list builder emitted `PushScrollFrame` for); transform

409

/// membership from the GPU value cache's `css_transform_keys` via

410

/// `has_transform` (the exact set it wrapped in `PushReferenceFrame`). A node

411

/// with both nests the reference frame OUTSIDE the scroll frame, same as the

412

/// builder.

413

679

fn compute_node_chains(

414

679

    layout_result: &DomLayoutResult,

415

679

    dom_id: DomId,

416

679

    base_chain: u32,

417

679

    has_transform: &dyn Fn(NodeId) -> bool,

418

679

    chains: &mut Vec<Vec<HitChainLink>>,

419

679

    chain_lookup: &mut std::collections::HashMap<Vec<HitChainLink>, u32>,

420

679

) -> Vec<u32> {

421

679

    let nodes = &layout_result.layout_tree.nodes;

422

679

    let scroll_ids = &layout_result.scroll_ids;

423

679

    let mut chain_of: Vec<u32> = vec![u32::MAX; nodes.len()];

424

679

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

425

6797

    for start in 0..nodes.len() {

426

6797

        if chain_of[start] != u32::MAX {

427

            continue;

428

6797

429

6797

        path.clear();

430

6797

        path.push(start);

431

6797

        let mut cur = nodes[start].parent;

432

6797

        while let Some(p) = cur {

433

6119

            if chain_of[p] != u32::MAX || path.len() > nodes.len() {

434

6119

                break;

435

436

            path.push(p);

437

            cur = nodes[p].parent;

438

439

6797

        for &idx in path.iter().rev() {

440

6797

            let c = nodes[idx].parent.map_or(base_chain, |p| {

441

6119

                let pc = if chain_of[p] == u32::MAX {

442

                    base_chain // cycle guard tripped; degrade gracefully

443

                } else {

444

6119

                    chain_of[p]

445

};

446

6119

                let is_scroll = scroll_ids.contains_key(&LayoutNodeId::new(p));

447

6119

                let pnid = nodes[p].dom_node_id;

448

6119

                let parent_transforms = pnid.is_some_and(has_transform);

449

6119

                match (pnid, is_scroll || parent_transforms) {

450

1428

                    (Some(pnid), true) => {

451

1428

                        let mut v = chains[pc as usize].clone();

452

1428

                        if parent_transforms {

453

10

                            v.push(HitChainLink::Transform(dom_id, pnid));

454

1418

455

1428

                        if is_scroll {

456

1418

                            v.push(HitChainLink::Scroll(dom_id, pnid));

457

1418

458

1428

                        intern_chain(chains, chain_lookup, v)

459

460

4691

                    _ => pc,

461

462

6119

});

463

6797

            chain_of[idx] = c;

464

465

466

679

    chain_of

467

679

468

469

/// A resolved `VirtualView` child-DOM placement.

470

///

471

/// The composite rect in window space plus the host-side chain (scroll

472

/// frames AND reference frames) active at the `VirtualView` item.

473

struct Placement {

474

    rect: LogicalRect,

475

    chain: Vec<HitChainLink>,

476

477

478

/// Resolve where each `VirtualView` / iframe child DOM lives on screen.

479

///

480

/// Child DOMs lay out in CHILD-LOCAL coordinates (origin 0,0) but live on

481

/// screen at the host `VirtualView` item's bounds. Hit entries must be

482

/// TRANSLATED there and CLIPPED to the composite bounds — otherwise the

483

/// child's nodes claim pointer events across the whole window (live bug:

484

/// azul-maps' tile grid ate every click on the header toolbar, so the

485

/// buttons never fired; the same escape the renderer had before

486

/// `intersect_clips()`).

487

///

488

/// Placements resolve iteratively so nested `VirtualView`s accumulate their

489

/// host offsets (a child's own `VirtualView` item is in that child's local

490

/// space). They also carry the host-side chain active at the `VirtualView`

491

/// item: if the host scrolls or transforms, the child viewport (and all of

492

/// the child's content) moves on screen with it. The chain is read off the

493

/// host display list by tracking `PushScrollFrame`/`PopScrollFrame` and

494

/// `PushReferenceFrame`/`PopReferenceFrame` nesting around the

495

/// `VirtualView` item — the same nesting the renderer applies when it

496

/// composites the child. Reference-frame owners come from

497

/// `DisplayList::node_mapping` (item index → source node).

498

729

fn resolve_virtual_view_placements(

499

729

    layout_results: &BTreeMap<DomId, DomLayoutResult>,

500

729

) -> BTreeMap<DomId, Placement> {

501

729

    let mut placements: BTreeMap<DomId, Placement> = BTreeMap::new();

502

736

    for _ in 0..4 {

503

        // bounded depth; each pass resolves one nesting level

504

736

        let mut changed = false;

505

1429

        for (host_dom, lr) in layout_results {

506

693

            let (host_offset, host_chain) = if host_dom.inner == 0 {

507

676

                (LogicalPosition::zero(), Vec::new())

508

17

            } else if let Some(p) = placements.get(host_dom) {

509

14

                (p.rect.origin, p.chain.clone())

510

            } else {

511

3

                continue;

512

};

513

690

            let base_depth = host_chain.len();

514

690

            let mut stack = host_chain;

515

15878

            for (item_idx, item) in lr.display_list.items.iter().enumerate() {

516

                use crate::solver3::display_list::DisplayListItem as I;

517

15845

                match item {

518

150

                    I::PushScrollFrame { scroll_id, .. } => {

519

                        // `scroll_id` is the owning node's layout index by

520

                        // construction (`get_scroll_id`); the reverse map

521

                        // is authoritative, the index a safe fallback.

522

150

                        let nid = lr

523

150

                            .scroll_id_to_node_id

524

150

                            .get(scroll_id)

525

150

                            .copied()

526

150

                            .unwrap_or_else(|| {

527

                                NodeId::new(usize::try_from(*scroll_id).unwrap_or(usize::MAX))

528

});

529

150

                        stack.push(HitChainLink::Scroll(*host_dom, nid));

530

531

                    I::PopScrollFrame => {

532

                        // Never pop below the host's own chain.

533

150

                        if matches!(stack.last(), Some(HitChainLink::Scroll(..)))

534

150

                            && stack.len() > base_depth

535

150

536

150

                            stack.pop();

537

150

538

539

110

                    I::PushReferenceFrame { .. } => {

540

110

                        // The owner node comes from node_mapping; a frame

541

110

                        // with no source node (scrollbar thumbs) still

542

110

                        // needs a stack entry for pop symmetry — use a

543

110

                        // link that resolves to no transform.

544

110

                        let nid = lr

545

110

                            .display_list

546

110

                            .node_mapping

547

110

                            .get(item_idx)

548

110

                            .copied()

549

110

                            .flatten()

550

110

                            .unwrap_or(NodeId::ZERO);

551

110

                        stack.push(HitChainLink::Transform(*host_dom, nid));

552

110

553

                    I::PopReferenceFrame => {

554

110

                        if matches!(stack.last(), Some(HitChainLink::Transform(..)))

555

110

                            && stack.len() > base_depth

556

110

557

110

                            stack.pop();

558

110

559

560

                    I::VirtualView {

561

16

                        child_dom_id,

562

16

                        bounds,

563

..

564

                    } => {

565

16

                        let b = *bounds.inner();

566

16

                        let absolute = LogicalRect {

567

16

                            origin: LogicalPosition {

568

16

                                x: b.origin.x + host_offset.x,

569

16

                                y: b.origin.y + host_offset.y,

570

16

},

571

16

                            size: b.size,

572

16

};

573

16

                        let differs = placements.get(child_dom_id).is_none_or(|p| {

574

8

                            p.rect != absolute || p.chain != stack

575

8

});

576

16

                        if differs {

577

8

                            placements.insert(

578

8

                                *child_dom_id,

579

8

                                Placement {

580

8

                                    rect: absolute,

581

8

                                    chain: stack.clone(),

582

8

},

583

8

);

584

8

                            changed = true;

585

8

586

587

15309

                    _ => {}

588

589

590

591

736

        if !changed {

592

729

            break;

593

7

594

595

729

    placements

596

729

597

598

impl CpuHitTester {

599

    /// Create a new empty hit tester.

600

121

    #[must_use] pub fn new() -> Self {

601

121

        Self {

602

121

            node_rects: BTreeMap::new(),

603

121

            chains: vec![Vec::new()],

604

121

            scroll_containers: Vec::new(),

605

121

            dom_placements: BTreeMap::new(),

606

121

607

121

608

609

    /// Resolve an interned chain against the current scroll offsets and

610

    /// transform values, then map a screen point into the chain's local

611

    /// (static layout) space.

612

6

    fn map_point_through_chain(

613

6

        &self,

614

6

        chain: u32,

615

6

        p: LogicalPosition,

616

6

        resolve_scroll: &dyn Fn(DomId, NodeId) -> Option<LogicalPosition>,

617

6

        resolve_transform: &dyn Fn(

618

6

            DomId,

619

6

            NodeId,

620

6

        ) -> Option<azul_core::transform::ComputedTransform3D>,

621

6

    ) -> LogicalPosition {

622

6

        self.chains.get(chain as usize).map_or(p, |elems| {

623

6

            resolve_chain(elems, resolve_scroll, resolve_transform).map_screen_to_local(p)

624

6

})

625

6

626

627

    /// Sum of `HitTestEntry` counts across all `DomIds` (for leak probes).

628

29

    #[must_use] pub fn node_rects_total(&self) -> usize {

629

29

        self.node_rects.values().map(Vec::len).sum()

630

29

631

632

    /// Rebuild the hit test structure from layout results.

633

///

634

    /// Called after each layout pass. Extracts positioned rectangles from

635

    /// `LayoutWindow::layout_results` and builds a flat list for fast

636

    /// point-in-rect testing.

637

67

    pub fn rebuild_from_layout(

638

67

        &mut self,

639

67

        layout_results: &BTreeMap<DomId, DomLayoutResult>,

640

67

) {

641

67

        self.rebuild_from_layout_with_gpu(layout_results, None);

642

67

643

644

    /// Like [`Self::rebuild_from_layout`], but transform-aware: `gpu` is the

645

    /// window's [`GpuStateManager`](crate::managers::gpu_state::GpuStateManager),

646

    /// whose per-DOM `css_transform_keys` is the EXACT set of nodes the

647

    /// display list wrapped in `PushReferenceFrame` (the display-list builder

648

    /// reads the same cache) — so hit-test chains and painted frames cannot

649

    /// disagree about which nodes transform. Pass `None` only when no

650

    /// transforms can exist (unit tests, static popups).

651

    /// The DOM node ids currently registered as USER-wheel scroll targets.

652

    /// Test/introspection helper: programmatically-scrollable-only containers

653

    /// (`overflow: hidden`) must never appear here.

654

    #[must_use]

655

9

    pub fn debug_scroll_container_nodes(&self) -> Vec<NodeId> {

656

9

        self.scroll_containers.iter().map(|e| e.node_id).collect()

657

9

658

659

729

    pub fn rebuild_from_layout_with_gpu(

660

729

        &mut self,

661

729

        layout_results: &BTreeMap<DomId, DomLayoutResult>,

662

729

        gpu: Option<&crate::managers::gpu_state::GpuStateManager>,

663

729

) {

664

729

        self.node_rects.clear();

665

729

        self.chains.clear();

666

729

        self.chains.push(Vec::new()); // chain 0 = empty

667

729

        self.scroll_containers.clear();

668

729

        self.dom_placements.clear();

669

670

729

        let placements = resolve_virtual_view_placements(layout_results);

671

672

729

        let mut chain_lookup: std::collections::HashMap<Vec<HitChainLink>, u32> =

673

729

            std::collections::HashMap::new();

674

729

        chain_lookup.insert(Vec::new(), 0);

675

737

        for (dom_id, p) in &placements {

676

8

            self.dom_placements.insert(*dom_id, p.rect);

677

8

678

679

1408

        for (dom_id, layout_result) in layout_results {

680

679

            let mut entries = Vec::new();

681

682

679

            let positions = &layout_result.calculated_positions;

683

679

            let nodes = &layout_result.layout_tree.nodes;

684

679

            let styled_dom = &layout_result.styled_dom;

685

686

            // Child DOM: shift into window space + clip to the composite rect.

687

679

            let (offset, dom_clip, base_chain_vec) = placements.get(dom_id).map_or_else(

688

672

                || (LogicalPosition::zero(), None, Vec::new()),

689

7

                |p| (p.rect.origin, Some(p.rect), p.chain.clone()),

690

);

691

679

            let base_chain = intern_chain(&mut self.chains, &mut chain_lookup, base_chain_vec);

692

679

            let dom_clip_entry = dom_clip.map(|r| (r, base_chain));

693

694

679

            let scroll_ids = &layout_result.scroll_ids;

695

679

            let transform_nodes = gpu

696

679

                .and_then(|g| g.caches.get(dom_id))

697

679

                .map(|c| &c.css_transform_keys);

698

679

            let chain_of = compute_node_chains(

699

679

                layout_result,

700

679

                *dom_id,

701

679

                base_chain,

702

6099

                &|n| transform_nodes.is_some_and(|t| t.contains_key(&n)),

703

679

                &mut self.chains,

704

679

                &mut chain_lookup,

705

);

706

707

            // Scroll containers of this DOM, for wheel-target containment.

708

            // Only USER-scrollable containers become wheel targets:

709

            // overflow:hidden boxes carry scroll ids (programmatic

710

            // scrolling - scroll-into-view, callback offsets - reaches

711

            // them), but css-overflow-3 disables their user-triggered

712

            // scrolling, so the hit-tester must not route the wheel there.

713

901

            for (&layout_idx, &scroll_id) in scroll_ids {

714

222

                let Some(n) = nodes.get(layout_idx.index()) else { continue };

715

222

                let Some(node_id) = n.dom_node_id else { continue };

716

222

                let (Some(pos), Some(size)) = (positions.get(layout_idx.index()), n.used_size) else {

717

                    continue;

718

};

719

222

                let user_scrollable = styled_dom

720

222

                    .styled_nodes

721

222

                    .as_container()

722

222

                    .get(node_id)

723

222

                    .is_some_and(|sn| {

724

222

                        let st = &sn.styled_node_state;

725

222

                        get_overflow_x(styled_dom, node_id, st)

726

222

                            .allows_user_scrolling()

727

222

                            || get_overflow_y(styled_dom, node_id, st)

728

222

                                .allows_user_scrolling()

729

222

});

730

222

                if !user_scrollable {

731

72

                    continue;

732

150

733

150

                self.scroll_containers.push(ScrollContainerEntry {

734

150

                    dom_id: *dom_id,

735

150

                    node_id,

736

150

                    layout_idx,

737

150

                    scroll_id,

738

150

                    rect: LogicalRect {

739

150

                        origin: LogicalPosition {

740

150

                            x: pos.x + offset.x,

741

150

                            y: pos.y + offset.y,

742

150

},

743

150

                        size,

744

150

},

745

150

                    chain: chain_of[layout_idx.index()],

746

150

});

747

748

749

            // Walk the layout nodes and their computed positions

750

6797

            for (idx, node) in nodes.iter().enumerate() {

751

                // Only include nodes that map to a real DOM node

752

6797

                let Some(node_id) = node.dom_node_id else {

753

9

                    continue; // skip anonymous boxes

754

};

755

756

                // Get the position for this layout node

757

6788

                let pos = match positions.get(idx) {

758

6786

                    Some(p) => *p,

759

2

                    None => continue,

760

};

761

762

                // Get the computed size

763

6786

                let Some(size) = node.used_size else {

764

1124

                    continue;

765

};

766

767

5662

                let rect = LogicalRect {

768

5662

                    origin: LogicalPosition {

769

5662

                        x: pos.x + offset.x,

770

5662

                        y: pos.y + offset.y,

771

5662

},

772

5662

                    size,

773

5662

};

774

775

                // Clip this node to the VirtualView composite bounds

776

                // (`dom_clip`) and every `overflow: hidden | clip | scroll |

777

                // auto` ancestor's box — otherwise a node that is scrolled or

778

                // clipped out of its ancestor would still claim pointer events.

779

5662

                let clips = compute_node_clips(

780

5662

                    styled_dom,

781

5662

                    nodes,

782

5662

                    positions,

783

5662

                    idx,

784

5662

                    offset,

785

5662

                    dom_clip_entry,

786

5662

                    &chain_of,

787

);

788

789

5662

                entries.push(HitTestEntry {

790

5662

                    node_id,

791

5662

                    rect,

792

5662

                    chain: chain_of[idx],

793

5662

                    clips,

794

5662

                    // azul has no `pointer-events` CSS property yet, so every laid-out

795

5662

                    // node is hit-testable. Populate this from the styled DOM once such

796

5662

                    // a property is added to `azul_css`.

797

5662

                    pointer_events_none: false,

798

5662

});

799

800

801

679

            self.node_rects.insert(*dom_id, entries);

802

803

729

804

805

    /// Perform a hit test at the given position, ignoring scroll offsets.

806

///

807

    /// Only correct for content that cannot scroll (e.g. menu popups) and for

808

    /// unit tests. Interactive windows must use [`Self::hit_test_scrolled`] —

809

    /// this wrapper tests the STATIC layout geometry, which is exactly the

810

    /// "clicks land on pre-scroll targets" bug for anything inside a scroll

811

    /// frame.

812

135

    #[must_use] pub fn hit_test(

813

135

        &self,

814

135

        position: LogicalPosition,

815

135

    ) -> Vec<(DomId, NodeId)> {

816

135

        self.hit_test_scrolled(position, &|_, _| None, &|_, _| None)

817

135

            .into_iter()

818

306

            .map(|(d, n, _)| (d, n))

819

135

            .collect()

820

135

821

822

    /// Perform a hit test at the given position with live scroll offsets and

823

    /// transform values.

824

///

825

    /// `resolve_scroll` returns the CURRENT scroll offset of a scroll

826

    /// container (`ScrollManager::get_current_offset`); `resolve_transform`

827

    /// the CURRENT matrix of a reference-frame owner

828

    /// (`GpuValueCache::css_current_transform_values` — the same map the CPU

829

    /// raster reads at paint time). Content painted at

830

    /// `T_total(static_pos − scroll_total)` is hit at the same place: a

831

    /// point `p` hits a node iff `T⁻¹(p) + scroll_total` lands in the node's

832

    /// static rect. Clip boxes are shifted by the clip OWNER's chain — a

833

    /// scroller's viewport clips where the viewport IS, not where its

834

    /// content went.

835

///

836

    /// Returns `(dom, node, local_point)` triples in reverse paint order

837

    /// (topmost first), where `local_point` is the query point mapped into

838

    /// that node's STATIC layout space — callers use it directly for

839

    /// node-relative points (caret placement, `point_relative_to_item`).

840

147

    #[must_use] pub fn hit_test_scrolled(

841

147

        &self,

842

147

        position: LogicalPosition,

843

147

        resolve_scroll: &dyn Fn(DomId, NodeId) -> Option<LogicalPosition>,

844

147

        resolve_transform: &dyn Fn(

845

147

            DomId,

846

147

            NodeId,

847

147

        ) -> Option<azul_core::transform::ComputedTransform3D>,

848

147

    ) -> Vec<(DomId, NodeId, LogicalPosition)> {

849

147

        let mut results = Vec::new();

850

851

        // Resolve every chain once per query, then map the point through it.

852

147

        let mapped: Vec<LogicalPosition> = self

853

147

            .chains

854

147

            .iter()

855

231

            .map(|chain| {

856

231

                resolve_chain(chain, resolve_scroll, resolve_transform)

857

231

                    .map_screen_to_local(position)

858

231

})

859

147

            .collect();

860

2130

        let local = |chain: u32| -> LogicalPosition {

861

2074

            mapped.get(chain as usize).copied().unwrap_or(position)

862

2074

};

863

864

243

        for (dom_id, entries) in &self.node_rects {

865

            // Walk in reverse (last painted = topmost)

866

1857

            for entry in entries.iter().rev() {

867

1845

                if entry.pointer_events_none {

868

                    continue;

869

1845

870

871

                // Every clip box must contain the point (each in its owner's

872

                // space).

873

1845

                if !entry

874

1845

                    .clips

875

1845

                    .iter()

876

1845

                    .all(|(clip, chain)| point_in_rect(local(*chain), clip))

877

878

567

                    continue;

879

1278

880

881

                // Check node rect in the node's local (static) space.

882

1278

                let p_local = local(entry.chain);

883

1278

                if point_in_rect(p_local, &entry.rect) {

884

260

                    results.push((*dom_id, entry.node_id, p_local));

885

1019

886

887

888

889

147

        results

890

147

891

892

893

/// Simple point-in-rect test.

894

2672

fn point_in_rect(point: LogicalPosition, rect: &LogicalRect) -> bool {

895

2672

    point.x >= rect.origin.x

896

2227

        && point.x < rect.origin.x + rect.size.width

897

725

        && point.y >= rect.origin.y

898

634

        && point.y < rect.origin.y + rect.size.height

899

2672

900

901

/// Convert CPU hit test results to `FullHitTest` format.

902

///

903

/// Maps `(DomId, NodeId)` pairs from [`CpuHitTester::hit_test`] into the same

904

/// `FullHitTest` structure that `WebRender`'s `fullhittest_new_webrender`

905

/// produces, so the event dispatch code works identically for both backends.

906

///

907

/// This lives HERE (next to the tester that produces its input) rather than in

908

/// the DLL, because two hosts consume it: the desktop shells

909

/// (`wr_translate2::convert_cpu_hit_test_to_full`, which now delegates) and the

910

/// headless E2E runner (`crate::e2e::runner`). Two copies of "which node did

911

/// the pointer land on" is exactly the divergence that makes a scenario pass in

912

/// one host and fail in the other.

913

#[allow(clippy::cast_possible_truncation)] // bounded: DomId/NodeId indices, hit depth

914

#[allow(clippy::too_many_lines)] // moved verbatim from the DLL; one pass per hit-test kind

915

#[must_use]

916

12

pub fn convert_cpu_hit_test_to_full(

917

12

    tester: &CpuHitTester,

918

12

    hits: &[(DomId, NodeId, LogicalPosition)],

919

12

    old_focus_node: Option<DomNodeId>,

920

12

    layout_results: &BTreeMap<DomId, DomLayoutResult>,

921

12

    cursor_position: LogicalPosition,

922

12

    resolve_scroll: &dyn Fn(DomId, NodeId) -> Option<LogicalPosition>,

923

12

    resolve_transform: &dyn Fn(DomId, NodeId) -> Option<azul_core::transform::ComputedTransform3D>,

924

12

) -> FullHitTest {

925

    use azul_core::{

926

        dom::OptionDomNodeId,

927

        hit_test::{HitTest, HitTestItem, OverflowingScrollNode, ScrollHitTestItem},

928

};

929

930

12

    let focused_node = old_focus_node.map_or(OptionDomNodeId::None, OptionDomNodeId::Some);

931

932

12

    let mut hovered_nodes: BTreeMap<DomId, HitTest> = BTreeMap::new();

933

934

39

    for (depth, (dom_id, node_id, local_point)) in hits.iter().enumerate() {

935

        // Compute point_relative_to_item in content-box coordinates.

936

        // `local_point` is the cursor already mapped into this node's STATIC

937

        // layout space (ancestor scroll offsets added back, ancestor

938

        // transforms inverted) — the same space the entry rects live in,

939

        // which is the node's static position translated by its VirtualView

940

        // placement. Subtract the node's static border-box position (plus

941

        // placement) AND padding+border to get content-box-local coordinates

942

        // that match the text layout coordinate space.

943

39

        let placement = tester

944

39

            .dom_placements

945

39

            .get(dom_id)

946

39

            .map_or_else(LogicalPosition::zero, |r| r.origin);

947

39

        let point_relative = layout_results

948

39

            .get(dom_id)

949

39

            .and_then(|lr| {

950

39

                lr.layout_tree

951

39

                    .dom_to_layout

952

39

                    .get(node_id)

953

39

                    .and_then(|indices| indices.first())

954

39

                    .and_then(|&idx| {

955

39

                        let node_pos = lr.calculated_positions.get(idx.index())?;

956

39

                        let node = lr.layout_tree.get(idx)?;

957

39

                        let bp = node.box_props.unpack();

958

39

                        let content_x =

959

39

                            node_pos.x + placement.x + bp.padding.left + bp.border.left;

960

39

                        let content_y =

961

39

                            node_pos.y + placement.y + bp.padding.top + bp.border.top;

962

39

                        Some(LogicalPosition::new(

963

39

                            local_point.x - content_x,

964

39

                            local_point.y - content_y,

965

39

))

966

39

})

967

39

})

968

39

            .unwrap_or_else(LogicalPosition::zero);

969

970

39

        let hit_test = hovered_nodes.entry(*dom_id).or_insert_with(|| HitTest {

971

12

            regular_hit_test_nodes: BTreeMap::new(),

972

12

            scroll_hit_test_nodes: BTreeMap::new(),

973

12

            scrollbar_hit_test_nodes: BTreeMap::new(),

974

12

            cursor_hit_test_nodes: BTreeMap::new(),

975

12

});

976

977

39

        hit_test.regular_hit_test_nodes.insert(

978

39

            *node_id,

979

39

            HitTestItem {

980

39

                point_in_viewport: cursor_position,

981

39

                point_relative_to_item: point_relative,

982

39

                is_focusable: false,

983

39

                is_virtual_view_hit: None,

984

39

                hit_depth: depth as u32,

985

39

},

986

);

987

988

989

    // Scroll containers: the CPU hit tester reports only regular DOM nodes,

990

    // so mirror the WR converter's TAG_TYPE_SCROLL_CONTAINER pass by rect

991

    // containment. Without this, scroll_hit_test_nodes stays empty on the

992

    // CPU-render path and wheel/trackpad scrolling never finds a target

993

    // (a11y scrolling still worked - it targets nodes directly - which is

994

    // how this stayed unnoticed).

995

//

996

    // Containment tests the container's ON-SCREEN viewport box: the static

997

    // box from the hit tester (already placement-translated for VirtualView

998

    // child DOMs), shifted by the container's OWN ancestors' current scroll

999

    // offsets — a scroller nested in a scrolled frame moves with that frame,

1000

    // while its own scrolling never moves its viewport. `parent_rect` /

1001

    // `child_rect` stay in static layout coordinates: downstream only uses

1002

    // their relative geometry (scroll ranges), which translation cannot

1003

    // change.

1004

18

    for sc in &tester.scroll_containers {

1005

6

        let dom_id = &sc.dom_id;

1006

6

        let node_id = sc.node_id;

1007

6

        let scroll_id = sc.scroll_id;

1008

6

        let Some(lr) = layout_results.get(dom_id) else {

1009

            continue;

1010

};

1011

6

        let layout_idx = sc.layout_idx;

1012

6

        let p_local = tester.map_point_through_chain(

1013

6

            sc.chain,

1014

6

            cursor_position,

1015

6

            resolve_scroll,

1016

6

            resolve_transform,

1017

);

1018

6

        let adj_x = p_local.x;

1019

6

        let adj_y = p_local.y;

1020

1021

6

            let node_pos = sc.rect.origin;

1022

6

            let node_size = sc.rect.size;

1023

6

            let inside = adj_x >= node_pos.x

1024

6

                && adj_x <= node_pos.x + node_size.width

1025

6

                && adj_y >= node_pos.y

1026

6

                && adj_y <= node_pos.y + node_size.height;

1027

6

            if !inside {

1028

                continue;

1029

6

1030

6

            let parent_rect = LogicalRect::new(node_pos, node_size);

1031

6

            let child_rect = compute_scroll_child_rect(lr, layout_idx.index(), parent_rect);

1032

1033

6

            let scroll_node = OverflowingScrollNode {

1034

6

                parent_rect,

1035

6

                child_rect,

1036

6

                virtual_child_rect: child_rect,

1037

6

                // CPU path has no WebRender document; the pipeline half of the

1038

6

                // external id is only used for WR scroll-layer sync.

1039

6

                parent_external_scroll_id: azul_core::hit_test::ExternalScrollId(

1040

6

                    scroll_id,

1041

6

                    azul_core::hit_test::PipelineId(dom_id.inner as u32, 0),

1042

6

),

1043

6

                parent_dom_hash: azul_core::dom::DomNodeHash {

1044

6

                    inner: node_id.index() as u64,

1045

6

},

1046

6

                scroll_tag_id: azul_core::dom::ScrollTagId {

1047

6

                    inner: azul_core::dom::TagId {

1048

6

                        inner: node_id.index() as u64,

1049

6

},

1050

6

},

1051

6

};

1052

6

            hovered_nodes

1053

6

                .entry(*dom_id)

1054

6

                .or_insert_with(HitTest::empty)

1055

6

                .scroll_hit_test_nodes

1056

6

                .insert(

1057

6

                    node_id,

1058

6

                    ScrollHitTestItem {

1059

6

                        point_in_viewport: cursor_position,

1060

6

                        // Relative to the container's ON-SCREEN viewport box

1061

6

                        // (static box shifted by the container's ancestors).

1062

6

                        point_relative_to_item: LogicalPosition::new(

1063

6

                            adj_x - node_pos.x,

1064

6

                            adj_y - node_pos.y,

1065

6

),

1066

6

                        scroll_node,

1067

6

},

1068

);

1069

1070

1071

1072

12

    FullHitTest {

1073

12

        hovered_nodes,

1074

12

        focused_node,

1075

12

1076

12

1077

1078

/// Compute the `child_rect` (scrollable content bounds) of an overflowing scroll

1079

/// node from the layout tree.

1080

///

1081

/// The content rect is anchored at the node's own border-box origin and sized to

1082

/// the node's overflow content size (`LayoutTree::get_content_size`, which honors

1083

/// `overflow_content_size` / inline text overflow). It is clamped to be at least

1084

/// as large as the viewport (`parent_rect`), so a node whose content does *not*

1085

/// overflow yields `child_rect == parent_rect` and the `ScrollState` clamping

1086

/// produces a zero scroll range (the prior, always-no-scroll behavior).

1087

#[must_use]

1088

6

pub fn compute_scroll_child_rect(

1089

6

    layout_result: &DomLayoutResult,

1090

6

    layout_idx: usize,

1091

6

    parent_rect: LogicalRect,

1092

6

) -> LogicalRect {

1093

6

    let content_size = layout_result.layout_tree.get_content_size(LayoutNodeId::new(layout_idx));

1094

6

    LogicalRect::new(

1095

6

        parent_rect.origin,

1096

6

        LogicalSize::new(

1097

6

            content_size.width.max(parent_rect.size.width),

1098

6

            content_size.height.max(parent_rect.size.height),

1099

),

1100

1101

6

1102

1103

/// Compute the hit-test clip boxes for a layout node: the host `VirtualView`

1104

/// composite bounds (`dom_clip_entry`) plus every clipping ancestor's border

1105

/// box (any `overflow` other than `visible`), each tagged with the chain of

1106

/// the clip OWNER's strict scroll ancestors so the query can shift each box

1107

/// into its own scrolled space.

1108

///

1109

/// Clipping is tracked per-axis because `overflow-x` / `overflow-y` are

1110

/// independent — an axis the ancestor does not clip is widened to

1111

/// [`CLIP_UNBOUNDED`] (kept finite so `origin + size` arithmetic never

1112

/// produces `inf - inf = NaN`). The ancestor box used is the border box

1113

/// (`used_size`); CSS clips at the padding edge, but the slightly larger

1114

/// border box is a safe over-inclusion for point hit-testing and avoids

1115

/// resolving padding/border here.

1116

#[allow(clippy::similar_names)] // domain-standard coordinate/geometry/short-lived names

1117

5697

fn compute_node_clips(

1118

5697

    styled_dom: &StyledDom,

1119

5697

    nodes: &[LayoutNodeHot],

1120

5697

    positions: &PositionVec,

1121

5697

    node_index: usize,

1122

5697

    offset: LogicalPosition,

1123

5697

    dom_clip_entry: Option<(LogicalRect, u32)>,

1124

5697

    chain_of: &[u32],

1125

5697

) -> Vec<(LogicalRect, u32)> {

1126

    // A non-finite edge must degrade to "unclipped on that side", never be

1127

    // stored: `point_in_rect` against a NaN rect is always false, which would

1128

    // make every node under a corrupt clip silently unhittable.

1129

2343

    fn sanitize_clip_rect(r: LogicalRect) -> LogicalRect {

1130

2343

        let min_x = if r.min_x().is_finite() { r.min_x() } else { -CLIP_UNBOUNDED };

1131

2343

        let min_y = if r.min_y().is_finite() { r.min_y() } else { -CLIP_UNBOUNDED };

1132

2343

        let max_x = if r.max_x().is_finite() { r.max_x() } else { CLIP_UNBOUNDED };

1133

2343

        let max_y = if r.max_y().is_finite() { r.max_y() } else { CLIP_UNBOUNDED };

1134

2343

        LogicalRect {

1135

2343

            origin: LogicalPosition { x: min_x, y: min_y },

1136

2343

            size: LogicalSize {

1137

2343

                width: (max_x - min_x).max(0.0),

1138

2343

                height: (max_y - min_y).max(0.0),

1139

2343

},

1140

2343

1141

2343

1142

1143

5697

    let mut clips = Vec::new();

1144

5697

    if let Some((dc, chain)) = dom_clip_entry {

1145

30

        clips.push((sanitize_clip_rect(dc), chain));

1146

5667

1147

1148

    // Walk ancestors. A node's own overflow clips its descendants, not itself, so

1149

    // we start at the parent. `guard` bounds the loop in case `parent` links ever

1150

    // form a cycle (they shouldn't, but a hit-test rebuild must never hang).

1151

5697

    let styled_nodes = styled_dom.styled_nodes.as_container();

1152

5697

    let mut cur = nodes.get(node_index).and_then(|n| n.parent);

1153

5697

    let mut guard = 0usize;

1154

23865

    while let Some(anc) = cur {

1155

18172

        guard += 1;

1156

18172

        if guard > nodes.len() {

1157

3

            break;

1158

18169

1159

18169

        let Some(anc_node) = nodes.get(anc) else { break };

1160

18168

        cur = anc_node.parent;

1161

1162

18168

        let Some(anc_dom_id) = anc_node.dom_node_id else {

1163

5

            continue;

1164

};

1165

18163

        let node_state = &styled_nodes[anc_dom_id].styled_node_state;

1166

18163

        let clips_x = get_overflow_x(styled_dom, anc_dom_id, node_state).is_clipped();

1167

18163

        let clips_y = get_overflow_y(styled_dom, anc_dom_id, node_state).is_clipped();

1168

18163

        if !clips_x && !clips_y {

1169

15849

            continue;

1170

2314

1171

2314

        let (Some(pos), Some(size)) = (positions.get(anc), anc_node.used_size) else {

1172

1

            continue;

1173

};

1174

2313

        let (ax0, ay0) = (pos.x + offset.x, pos.y + offset.y);

1175

2313

        let (min_x, max_x) = if clips_x {

1176

1219

            (ax0, ax0 + size.width)

1177

        } else {

1178

1094

            (-CLIP_UNBOUNDED, CLIP_UNBOUNDED)

1179

};

1180

2313

        let (min_y, max_y) = if clips_y {

1181

2312

            (ay0, ay0 + size.height)

1182

        } else {

1183

1

            (-CLIP_UNBOUNDED, CLIP_UNBOUNDED)

1184

};

1185

2313

        clips.push((

1186

2313

            sanitize_clip_rect(LogicalRect {

1187

2313

                origin: LogicalPosition { x: min_x, y: min_y },

1188

2313

                size: LogicalSize {

1189

2313

                    width: (max_x - min_x).max(0.0),

1190

2313

                    height: (max_y - min_y).max(0.0),

1191

2313

},

1192

2313

}),

1193

2313

            chain_of.get(anc).copied().unwrap_or(0),

1194

2313

));

1195

1196

1197

5697

    clips

1198

5697

1199

1200

/// Test-compat shim for the pre-scroll-aware single-rect clip API: the static

1201

/// intersection of every clip box from [`compute_node_clips`] — exactly what

1202

/// the query evaluates when nothing is scrolled. Kept so the generated clip

1203

/// tests keep asserting the per-axis clip semantics they were written for.

1204

#[cfg(test)]

1205

35

fn compute_node_clip(

1206

35

    styled_dom: &StyledDom,

1207

35

    nodes: &[LayoutNodeHot],

1208

35

    positions: &PositionVec,

1209

35

    node_index: usize,

1210

35

    offset: LogicalPosition,

1211

35

    dom_clip: Option<LogicalRect>,

1212

35

) -> Option<LogicalRect> {

1213

35

    let chain_of = vec![0u32; nodes.len()];

1214

35

    let clips = compute_node_clips(

1215

35

        styled_dom,

1216

35

        nodes,

1217

35

        positions,

1218

35

        node_index,

1219

35

        offset,

1220

35

        dom_clip.map(|r| (r, 0)),

1221

35

        &chain_of,

1222

);

1223

35

    if clips.is_empty() {

1224

9

        return None;

1225

26

1226

26

    let (mut min_x, mut min_y, mut max_x, mut max_y) = (

1227

26

        -CLIP_UNBOUNDED,

1228

26

        -CLIP_UNBOUNDED,

1229

26

        CLIP_UNBOUNDED,

1230

26

        CLIP_UNBOUNDED,

1231

26

);

1232

53

    for (r, _) in &clips {

1233

27

        min_x = min_x.max(r.min_x());

1234

27

        min_y = min_y.max(r.min_y());

1235

27

        max_x = max_x.min(r.max_x());

1236

27

        max_y = max_y.min(r.max_y());

1237

27

1238

26

    Some(LogicalRect {

1239

26

        origin: LogicalPosition { x: min_x, y: min_y },

1240

26

        size: LogicalSize {

1241

26

            width: (max_x - min_x).max(0.0),

1242

26

            height: (max_y - min_y).max(0.0),

1243

26

},

1244

26

})

1245

35

1246

1247

#[cfg(test)]

1248

mod tests {

1249

    use super::*;

1250

1251

    #[test]

1252

1

    fn test_cpu_hit_tester_empty() {

1253

1

        let tester = CpuHitTester::new();

1254

1

        let results = tester.hit_test(LogicalPosition { x: 100.0, y: 100.0 });

1255

1

        assert!(results.is_empty());

1256

1

1257

1258

    #[test]

1259

1

    fn test_point_in_rect() {

1260

1

        let rect = LogicalRect {

1261

1

            origin: LogicalPosition { x: 10.0, y: 10.0 },

1262

1

            size: LogicalSize {

1263

1

                width: 100.0,

1264

1

                height: 50.0,

1265

1

},

1266

1

};

1267

1268

        // Inside

1269

1

        assert!(point_in_rect(LogicalPosition { x: 50.0, y: 30.0 }, &rect));

1270

        // On edge

1271

1

        assert!(point_in_rect(LogicalPosition { x: 10.0, y: 10.0 }, &rect));

1272

        // Outside

1273

1

        assert!(!point_in_rect(LogicalPosition { x: 5.0, y: 5.0 }, &rect));

1274

1

        assert!(!point_in_rect(LogicalPosition { x: 200.0, y: 30.0 }, &rect));

1275

1

1276

1277

1278

#[cfg(test)]

1279

#[allow(clippy::float_cmp)] // clip/hit geometry must round-trip bit-exactly, not "approximately"

1280

mod autotest_generated {

1281

    use std::collections::HashMap;

1282

1283

    use azul_core::dom::{Dom, FormattingContext};

1284

1285

    use super::*;

1286

    use crate::{

1287

        solver3::{

1288

            display_list::{DisplayList, DisplayListItem, WindowLogicalRect},

1289

            layout_tree::LayoutTree,

1290

},

1291

        window::DomLayoutResult,

1292

};

1293

1294

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

1295

    // fixtures

1296

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

1297

1298

    fn p(x: f32, y: f32) -> LogicalPosition {

1299

        LogicalPosition { x, y }

1300

1301

1302

    fn r(x: f32, y: f32, width: f32, height: f32) -> LogicalRect {

1303

        LogicalRect {

1304

            origin: p(x, y),

1305

            size: LogicalSize { width, height },

1306

1307

1308

1309

    fn dom(inner: usize) -> DomId {

1310

        DomId { inner }

1311

1312

1313

    /// A layout node: `dom_node_id` as a raw index (`None` = anonymous box),

1314

    /// `size` as (w, h) (`None` = never laid out), `parent` as a node index.

1315

    fn hot(

1316

        dom_node_id: Option<usize>,

1317

        size: Option<(f32, f32)>,

1318

        parent: Option<usize>,

1319

    ) -> LayoutNodeHot {

1320

        LayoutNodeHot {

1321

            box_props: Default::default(),

1322

            dom_node_id: dom_node_id.map(NodeId::new),

1323

            used_size: size.map(|(width, height)| LogicalSize { width, height }),

1324

            formatting_context: FormattingContext::default(),

1325

            parent,

1326

1327

1328

1329

    /// `body > div.clip > div` (`NodeId` 0, 1, 2), styled by `css_src`.

1330

    fn styled(css_src: &str) -> StyledDom {

1331

        let css = azul_css::parser2::new_from_str(css_src).0;

1332

        let mut d = Dom::create_body().with_children(

1333

            vec![Dom::create_div()

1334

                .with_class("clip".to_string().into())

1335

                .with_children(vec![Dom::create_div()].into())]

1336

            .into(),

1337

);

1338

        StyledDom::create(&mut d, css)

1339

1340

1341

    fn layout_result(

1342

        styled_dom: StyledDom,

1343

        nodes: Vec<LayoutNodeHot>,

1344

        calculated_positions: PositionVec,

1345

        items: Vec<DisplayListItem>,

1346

    ) -> DomLayoutResult {

1347

        DomLayoutResult {

1348

            styled_dom,

1349

            layout_tree: LayoutTree {

1350

                nodes,

1351

                warm: Vec::new(),

1352

                cold: Vec::new(),

1353

                root: 0,

1354

                dom_to_layout: BTreeMap::new(),

1355

                children_arena: Vec::new(),

1356

                children_offsets: Vec::new(),

1357

                subtree_needs_intrinsic: Vec::new(),

1358

},

1359

            calculated_positions,

1360

            viewport: LogicalRect::zero(),

1361

            display_list: std::sync::Arc::new(DisplayList {

1362

                items,

1363

                ..Default::default()

1364

}),

1365

            scroll_ids: HashMap::new(),

1366

            scroll_id_to_node_id: HashMap::new(),

1367

1368

1369

1370

    fn virtual_view(child: usize, bounds: LogicalRect) -> DisplayListItem {

1371

        DisplayListItem::VirtualView {

1372

            child_dom_id: dom(child),

1373

            bounds: WindowLogicalRect::new(bounds.origin, bounds.size),

1374

            clip_rect: WindowLogicalRect::new(bounds.origin, bounds.size),

1375

            content_offset: Default::default(),

1376

1377

1378

1379

    /// Every f32 that can plausibly reach a hit test from a broken input event.

1380

    const HOSTILE_F32: [f32; 8] = [

1381

        0.0,

1382

        -0.0,

1383

        f32::NAN,

1384

        f32::INFINITY,

1385

        f32::NEG_INFINITY,

1386

        f32::MAX,

1387

        f32::MIN,

1388

        f32::MIN_POSITIVE,

1389

];

1390

1391

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

1392

    // point_in_rect  (numeric)

1393

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

1394

1395

    #[test]

1396

    fn point_in_rect_is_half_open_top_left_inclusive_bottom_right_exclusive() {

1397

        let rect = r(10.0, 10.0, 100.0, 50.0);

1398

1399

        assert!(point_in_rect(p(10.0, 10.0), &rect), "top-left is inclusive");

1400

        assert!(point_in_rect(p(109.999, 59.999), &rect));

1401

        assert!(

1402

            !point_in_rect(p(110.0, 30.0), &rect),

1403

            "right edge is exclusive"

1404

);

1405

        assert!(

1406

            !point_in_rect(p(50.0, 60.0), &rect),

1407

            "bottom edge is exclusive"

1408

);

1409

        assert!(!point_in_rect(p(110.0, 60.0), &rect));

1410

1411

1412

    #[test]

1413

    fn point_in_rect_zero_sized_rect_contains_nothing_not_even_its_origin() {

1414

        let rect = r(0.0, 0.0, 0.0, 0.0);

1415

        assert!(!point_in_rect(p(0.0, 0.0), &rect));

1416

        assert!(!point_in_rect(p(-0.0, -0.0), &rect));

1417

1418

        let elsewhere = r(7.0, 9.0, 0.0, 0.0);

1419

        assert!(!point_in_rect(p(7.0, 9.0), &elsewhere));

1420

1421

1422

    #[test]

1423

    fn point_in_rect_negative_size_rect_is_empty() {

1424

        // A rect whose size is negative has max < min on both axes: nothing is

1425

        // "inside" it, and in particular the test must not silently swap the

1426

        // edges and report a hit.

1427

        let rect = r(100.0, 100.0, -50.0, -50.0);

1428

        for x in [50.0_f32, 75.0, 99.0, 100.0, 125.0] {

1429

            for y in [50.0_f32, 75.0, 99.0, 100.0, 125.0] {

1430

                assert!(!point_in_rect(p(x, y), &rect), "({x}, {y}) must not hit");

1431

1432

1433

1434

1435

    #[test]

1436

    fn point_in_rect_negative_zero_origin_still_contains_zero() {

1437

        // -0.0 >= 0.0 and 0.0 >= -0.0 both hold: signed zero must not flip a hit.

1438

        let rect = r(-0.0, -0.0, 10.0, 10.0);

1439

        assert!(point_in_rect(p(0.0, 0.0), &rect));

1440

        assert!(point_in_rect(p(-0.0, -0.0), &rect));

1441

1442

        let zero_origin = r(0.0, 0.0, 10.0, 10.0);

1443

        assert!(point_in_rect(p(-0.0, -0.0), &zero_origin));

1444

1445

1446

    #[test]

1447

    fn point_in_rect_nan_point_never_hits() {

1448

        let rect = r(-1000.0, -1000.0, 5000.0, 5000.0);

1449

        assert!(!point_in_rect(p(f32::NAN, 0.0), &rect));

1450

        assert!(!point_in_rect(p(0.0, f32::NAN), &rect));

1451

        assert!(!point_in_rect(p(f32::NAN, f32::NAN), &rect));

1452

1453

1454

    #[test]

1455

    fn point_in_rect_nan_rect_never_hits() {

1456

        for bad in [f32::NAN, f32::INFINITY, f32::NEG_INFINITY] {

1457

            let nan_origin = r(bad, 0.0, 10.0, 10.0);

1458

            let nan_size = r(0.0, 0.0, bad, 10.0);

1459

            // NaN origin/size makes every comparison false except the trivially

1460

            // true ones; the only thing that matters is that it doesn't panic and

1461

            // that a NaN box can't claim an arbitrary point.

1462

            let _ = point_in_rect(p(5.0, 5.0), &nan_origin);

1463

            let _ = point_in_rect(p(5.0, 5.0), &nan_size);

1464

1465

        assert!(!point_in_rect(p(5.0, 5.0), &r(f32::NAN, 0.0, 10.0, 10.0)));

1466

        assert!(!point_in_rect(p(5.0, 5.0), &r(0.0, 0.0, f32::NAN, 10.0)));

1467

1468

1469

    #[test]

1470

    fn point_in_rect_infinite_extent_is_empty_which_is_why_clip_unbounded_exists() {

1471

        // origin = -inf, size = +inf  =>  origin + size = NaN  =>  `x < NaN` is

1472

        // false  =>  nothing is inside. This is exactly the trap CLIP_UNBOUNDED

1473

        // documents; the assertion pins the failure mode so nobody "optimizes"

1474

        // CLIP_UNBOUNDED back into f32::INFINITY.

1475

        let infinite = LogicalRect {

1476

            origin: p(f32::NEG_INFINITY, f32::NEG_INFINITY),

1477

            size: LogicalSize {

1478

                width: f32::INFINITY,

1479

                height: f32::INFINITY,

1480

},

1481

};

1482

        assert!(!point_in_rect(p(0.0, 0.0), &infinite));

1483

        assert!(!point_in_rect(p(-1.0e6, 1.0e6), &infinite));

1484

1485

1486

    #[test]

1487

    fn point_in_rect_clip_unbounded_extent_contains_every_realistic_coordinate() {

1488

        // The finite stand-in that compute_node_clip uses must behave like

1489

        // "unbounded" for any coordinate a real window can produce.

1490

        let unbounded = r(

1491

            -CLIP_UNBOUNDED,

1492

            -CLIP_UNBOUNDED,

1493

            2.0 * CLIP_UNBOUNDED,

1494

            2.0 * CLIP_UNBOUNDED,

1495

);

1496

        for c in [0.0_f32, -0.0, 1.0, -1.0, 99_999.0, -99_999.0, 1.0e6, -1.0e6] {

1497

            assert!(point_in_rect(p(c, c), &unbounded), "{c} must be inside");

1498

1499

        // ...but it is finite, so it does NOT swallow f32::MAX.

1500

        assert!(!point_in_rect(p(f32::MAX, 0.0), &unbounded));

1501

1502

1503

    #[test]

1504

    fn point_in_rect_saturates_at_f32_max_without_panicking() {

1505

        // origin + size overflows to +inf here; `x < inf` is true, so the point

1506

        // is reported inside. No debug-panic, no wraparound.

1507

        let huge = r(f32::MAX, f32::MAX, f32::MAX, f32::MAX);

1508

        assert!(point_in_rect(p(f32::MAX, f32::MAX), &huge));

1509

        assert!(!point_in_rect(p(0.0, 0.0), &huge));

1510

1511

        let from_zero = r(0.0, 0.0, f32::MAX, f32::MAX);

1512

        assert!(point_in_rect(p(0.0, 0.0), &from_zero));

1513

        assert!(

1514

            !point_in_rect(p(f32::MAX, f32::MAX), &from_zero),

1515

            "the far edge stays exclusive even at f32::MAX"

1516

);

1517

1518

1519

    #[test]

1520

    fn point_in_rect_never_panics_for_any_hostile_f32_combination() {

1521

        for &x in &HOSTILE_F32 {

1522

            for &y in &HOSTILE_F32 {

1523

                for &w in &HOSTILE_F32 {

1524

                    let rect = r(x, y, w, w);

1525

                    let _ = point_in_rect(p(y, x), &rect);

1526

1527

1528

1529

1530

1531

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

1532

    // CpuHitTester::new / node_rects_total  (constructor + getter)

1533

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

1534

1535

    #[test]

1536

    fn new_hit_tester_is_empty_and_matches_default() {

1537

        let tester = CpuHitTester::new();

1538

        assert_eq!(tester.node_rects_total(), 0);

1539

        assert!(tester.hit_test(p(0.0, 0.0)).is_empty());

1540

1541

        let defaulted = CpuHitTester::default();

1542

        assert_eq!(defaulted.node_rects_total(), tester.node_rects_total());

1543

1544

1545

    #[test]

1546

    fn node_rects_total_sums_entries_across_doms_and_skips_unlaid_nodes() {

1547

        let mut results = BTreeMap::new();

1548

        // dom 0: 2 hit-testable nodes + 1 anonymous + 1 without a used_size

1549

        results.insert(

1550

            dom(0),

1551

            layout_result(

1552

                styled(""),

1553

                vec![

1554

                    hot(Some(0), Some((10.0, 10.0)), None),

1555

                    hot(Some(1), Some((10.0, 10.0)), None),

1556

                    hot(None, Some((10.0, 10.0)), None), // anonymous box

1557

                    hot(Some(2), None, None),            // never laid out

1558

],

1559

                vec![p(0.0, 0.0), p(0.0, 0.0), p(0.0, 0.0), p(0.0, 0.0)],

1560

                Vec::new(),

1561

),

1562

);

1563

        // dom 1: 1 hit-testable node

1564

        results.insert(

1565

            dom(1),

1566

            layout_result(

1567

                styled(""),

1568

                vec![hot(Some(0), Some((10.0, 10.0)), None)],

1569

                vec![p(0.0, 0.0)],

1570

                Vec::new(),

1571

),

1572

);

1573

1574

        let mut tester = CpuHitTester::new();

1575

        tester.rebuild_from_layout(&results);

1576

        assert_eq!(tester.node_rects_total(), 3);

1577

1578

1579

    #[test]

1580

    fn node_rects_total_does_not_grow_when_the_same_layout_is_rebuilt() {

1581

        // Leak probe: rebuild_from_layout must clear, not append.

1582

        let mut results = BTreeMap::new();

1583

        results.insert(

1584

            dom(0),

1585

            layout_result(

1586

                styled(""),

1587

                vec![hot(Some(0), Some((10.0, 10.0)), None)],

1588

                vec![p(0.0, 0.0)],

1589

                Vec::new(),

1590

),

1591

);

1592

1593

        let mut tester = CpuHitTester::new();

1594

        for _ in 0..16 {

1595

            tester.rebuild_from_layout(&results);

1596

            assert_eq!(tester.node_rects_total(), 1);

1597

1598

1599

        tester.rebuild_from_layout(&BTreeMap::new());

1600

        assert_eq!(tester.node_rects_total(), 0);

1601

        assert!(tester.hit_test(p(1.0, 1.0)).is_empty());

1602

1603

1604

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

1605

    // CpuHitTester::hit_test  (numeric)

1606

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

1607

1608

    #[test]

1609

    fn hit_test_on_empty_tester_never_panics_for_hostile_positions() {

1610

        let tester = CpuHitTester::new();

1611

        for &x in &HOSTILE_F32 {

1612

            for &y in &HOSTILE_F32 {

1613

                assert!(tester.hit_test(p(x, y)).is_empty());

1614

1615

1616

1617

1618

    #[test]

1619

    fn hit_test_with_hostile_positions_against_a_real_node_returns_no_spurious_hits() {

1620

        let mut results = BTreeMap::new();

1621

        results.insert(

1622

            dom(0),

1623

            layout_result(

1624

                styled(""),

1625

                vec![hot(Some(0), Some((100.0, 100.0)), None)],

1626

                vec![p(0.0, 0.0)],

1627

                Vec::new(),

1628

),

1629

);

1630

        let mut tester = CpuHitTester::new();

1631

        tester.rebuild_from_layout(&results);

1632

1633

        // Sanity: the node IS hittable at a normal coordinate.

1634

        assert_eq!(tester.hit_test(p(50.0, 50.0)).len(), 1);

1635

1636

        for pos in [

1637

            p(f32::NAN, f32::NAN),

1638

            p(f32::NAN, 50.0),

1639

            p(50.0, f32::NAN),

1640

            p(f32::INFINITY, f32::INFINITY),

1641

            p(f32::NEG_INFINITY, f32::NEG_INFINITY),

1642

            p(f32::MAX, f32::MAX),

1643

            p(f32::MIN, f32::MIN),

1644

] {

1645

            assert!(

1646

                tester.hit_test(pos).is_empty(),

1647

                "({}, {}) must not hit a 0,0,100x100 node",

1648

                pos.x,

1649

                pos.y

1650

);

1651

1652

1653

        // Zero and negative zero are inside (origin is inclusive).

1654

        assert_eq!(tester.hit_test(p(0.0, 0.0)).len(), 1);

1655

        assert_eq!(tester.hit_test(p(-0.0, -0.0)).len(), 1);

1656

        // The exclusive far edge.

1657

        assert!(tester.hit_test(p(100.0, 100.0)).is_empty());

1658

        assert_eq!(tester.hit_test(p(99.999, 99.999)).len(), 1);

1659

1660

1661

    #[test]

1662

    fn hit_test_returns_topmost_first() {

1663

        // Two fully overlapping siblings: the one that paints last (higher index)

1664

        // must come back first.

1665

        let mut results = BTreeMap::new();

1666

        results.insert(

1667

            dom(0),

1668

            layout_result(

1669

                styled(""),

1670

                vec![

1671

                    hot(Some(1), Some((100.0, 100.0)), None),

1672

                    hot(Some(2), Some((100.0, 100.0)), None),

1673

],

1674

                vec![p(0.0, 0.0), p(0.0, 0.0)],

1675

                Vec::new(),

1676

),

1677

);

1678

        let mut tester = CpuHitTester::new();

1679

        tester.rebuild_from_layout(&results);

1680

1681

        assert_eq!(

1682

            tester.hit_test(p(50.0, 50.0)),

1683

            vec![(dom(0), NodeId::new(2)), (dom(0), NodeId::new(1))]

1684

);

1685

1686

1687

    #[test]

1688

    fn hit_test_skips_nodes_with_no_calculated_position() {

1689

        // `calculated_positions` shorter than `nodes` is a torn/partial layout:

1690

        // the extra nodes must be dropped, not indexed out of bounds.

1691

        let mut results = BTreeMap::new();

1692

        results.insert(

1693

            dom(0),

1694

            layout_result(

1695

                styled(""),

1696

                vec![

1697

                    hot(Some(0), Some((100.0, 100.0)), None),

1698

                    hot(Some(1), Some((100.0, 100.0)), None),

1699

                    hot(Some(2), Some((100.0, 100.0)), None),

1700

],

1701

                vec![p(0.0, 0.0)], // only node 0 has a position

1702

                Vec::new(),

1703

),

1704

);

1705

        let mut tester = CpuHitTester::new();

1706

        tester.rebuild_from_layout(&results);

1707

1708

        assert_eq!(tester.node_rects_total(), 1);

1709

        assert_eq!(tester.hit_test(p(50.0, 50.0)), vec![(dom(0), NodeId::ZERO)]);

1710

1711

1712

    #[test]

1713

    fn hit_test_respects_an_overflow_hidden_ancestor() {

1714

        // body(0) 500x500 > div.clip(1) 100x100 overflow:hidden > div(2) 400x400.

1715

        // A point at (200,200) is inside node 2's rect but scrolled/clipped out of

1716

        // its ancestor, so only the body may claim it.

1717

        let mut results = BTreeMap::new();

1718

        results.insert(

1719

            dom(0),

1720

            layout_result(

1721

                styled("div.clip { overflow: hidden; }"),

1722

                vec![

1723

                    hot(Some(0), Some((500.0, 500.0)), None),

1724

                    hot(Some(1), Some((100.0, 100.0)), Some(0)),

1725

                    hot(Some(2), Some((400.0, 400.0)), Some(1)),

1726

],

1727

                vec![p(0.0, 0.0), p(0.0, 0.0), p(0.0, 0.0)],

1728

                Vec::new(),

1729

),

1730

);

1731

        let mut tester = CpuHitTester::new();

1732

        tester.rebuild_from_layout(&results);

1733

1734

        assert_eq!(

1735

            tester.hit_test(p(50.0, 50.0)),

1736

            vec![

1737

                (dom(0), NodeId::new(2)),

1738

                (dom(0), NodeId::new(1)),

1739

                (dom(0), NodeId::new(0)),

1740

],

1741

            "inside the clip: all three nodes are hit, topmost first"

1742

);

1743

        assert_eq!(

1744

            tester.hit_test(p(200.0, 200.0)),

1745

            vec![(dom(0), NodeId::new(0))],

1746

            "outside the clip: the clipped-out child must not eat the event"

1747

);

1748

1749

1750

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

1751

    // CpuHitTester::rebuild_from_layout  (VirtualView placement)

1752

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

1753

1754

    #[test]

1755

    fn rebuild_from_layout_with_no_doms_is_a_no_op() {

1756

        let mut tester = CpuHitTester::new();

1757

        tester.rebuild_from_layout(&BTreeMap::new());

1758

        assert_eq!(tester.node_rects_total(), 0);

1759

        assert!(tester.hit_test(p(0.0, 0.0)).is_empty());

1760

1761

1762

    #[test]

1763

    fn rebuild_translates_and_clips_virtual_view_child_doms() {

1764

        // Host dom 0 hosts child dom 1 at (100,100) 50x50. The child lays out in

1765

        // local coordinates with a 200x200 node at (0,0): it must be translated to

1766

        // (100,100) AND clipped to the 50x50 composite box, otherwise it claims

1767

        // pointer events across the whole window (the azul-maps tile-grid bug).

1768

        let mut results = BTreeMap::new();

1769

        results.insert(

1770

            dom(0),

1771

            layout_result(

1772

                styled(""),

1773

                Vec::new(),

1774

                Vec::new(),

1775

                vec![virtual_view(1, r(100.0, 100.0, 50.0, 50.0))],

1776

),

1777

);

1778

        results.insert(

1779

            dom(1),

1780

            layout_result(

1781

                styled(""),

1782

                vec![hot(Some(1), Some((200.0, 200.0)), None)],

1783

                vec![p(0.0, 0.0)],

1784

                Vec::new(),

1785

),

1786

);

1787

1788

        let mut tester = CpuHitTester::new();

1789

        tester.rebuild_from_layout(&results);

1790

1791

        assert!(

1792

            tester.hit_test(p(10.0, 10.0)).is_empty(),

1793

            "the child's local (10,10) is not its window position"

1794

);

1795

        assert_eq!(

1796

            tester.hit_test(p(120.0, 120.0)),

1797

            vec![(dom(1), NodeId::new(1))],

1798

            "translated into the host's VirtualView bounds"

1799

);

1800

        assert!(

1801

            tester.hit_test(p(180.0, 180.0)).is_empty(),

1802

            "inside the child's 200x200 rect but outside the 50x50 composite clip"

1803

);

1804

1805

1806

    #[test]

1807

    fn rebuild_accumulates_offsets_through_nested_virtual_views() {

1808

        // dom0 --VV(10,10)--> dom1 --VV(5,5 local)--> dom2, whose node sits at

1809

        // local (0,0): absolute origin must be (15,15).

1810

        let mut results = BTreeMap::new();

1811

        results.insert(

1812

            dom(0),

1813

            layout_result(

1814

                styled(""),

1815

                Vec::new(),

1816

                Vec::new(),

1817

                vec![virtual_view(1, r(10.0, 10.0, 200.0, 200.0))],

1818

),

1819

);

1820

        results.insert(

1821

            dom(1),

1822

            layout_result(

1823

                styled(""),

1824

                Vec::new(),

1825

                Vec::new(),

1826

                vec![virtual_view(2, r(5.0, 5.0, 100.0, 100.0))],

1827

),

1828

);

1829

        results.insert(

1830

            dom(2),

1831

            layout_result(

1832

                styled(""),

1833

                vec![hot(Some(1), Some((20.0, 20.0)), None)],

1834

                vec![p(0.0, 0.0)],

1835

                Vec::new(),

1836

),

1837

);

1838

1839

        let mut tester = CpuHitTester::new();

1840

        tester.rebuild_from_layout(&results);

1841

1842

        assert_eq!(

1843

            tester.hit_test(p(16.0, 16.0)),

1844

            vec![(dom(2), NodeId::new(1))]

1845

);

1846

        assert!(

1847

            tester.hit_test(p(14.0, 14.0)).is_empty(),

1848

            "(14,14) is before the doubly-offset origin (15,15)"

1849

);

1850

        assert!(tester.hit_test(p(36.0, 36.0)).is_empty());

1851

1852

1853

    #[test]

1854

    fn rebuild_ignores_virtual_views_pointing_at_a_missing_child_dom() {

1855

        let mut results = BTreeMap::new();

1856

        results.insert(

1857

            dom(0),

1858

            layout_result(

1859

                styled(""),

1860

                vec![hot(Some(0), Some((10.0, 10.0)), None)],

1861

                vec![p(0.0, 0.0)],

1862

                vec![virtual_view(42, r(0.0, 0.0, 10.0, 10.0))],

1863

),

1864

);

1865

1866

        let mut tester = CpuHitTester::new();

1867

        tester.rebuild_from_layout(&results);

1868

1869

        assert_eq!(tester.node_rects_total(), 1);

1870

        assert_eq!(tester.hit_test(p(5.0, 5.0)), vec![(dom(0), NodeId::ZERO)]);

1871

1872

1873

    #[test]

1874

    fn rebuild_terminates_on_a_cyclic_virtual_view_graph() {

1875

        // dom1 hosts dom2 and dom2 hosts dom1: neither is reachable from the root

1876

        // dom, so neither gets placed. The placement loop is bounded, so this must

1877

        // terminate (a hang here would freeze every layout pass).

1878

        let mut results = BTreeMap::new();

1879

        results.insert(

1880

            dom(1),

1881

            layout_result(

1882

                styled(""),

1883

                vec![hot(Some(1), Some((10.0, 10.0)), None)],

1884

                vec![p(0.0, 0.0)],

1885

                vec![virtual_view(2, r(1.0, 1.0, 10.0, 10.0))],

1886

),

1887

);

1888

        results.insert(

1889

            dom(2),

1890

            layout_result(

1891

                styled(""),

1892

                vec![hot(Some(1), Some((10.0, 10.0)), None)],

1893

                vec![p(0.0, 0.0)],

1894

                vec![virtual_view(1, r(2.0, 2.0, 10.0, 10.0))],

1895

),

1896

);

1897

1898

        let mut tester = CpuHitTester::new();

1899

        tester.rebuild_from_layout(&results);

1900

        assert_eq!(tester.node_rects_total(), 2);

1901

1902

1903

    #[test]

1904

    fn rebuild_handles_a_virtual_view_with_hostile_bounds() {

1905

        // A NaN/infinite composite box must not produce a NaN clip that panics or

1906

        // makes the child hit-testable everywhere.

1907

        for bad in [f32::NAN, f32::INFINITY, f32::NEG_INFINITY, f32::MAX] {

1908

            let mut results = BTreeMap::new();

1909

            results.insert(

1910

                dom(0),

1911

                layout_result(

1912

                    styled(""),

1913

                    Vec::new(),

1914

                    Vec::new(),

1915

                    vec![virtual_view(1, r(bad, bad, bad, bad))],

1916

),

1917

);

1918

            results.insert(

1919

                dom(1),

1920

                layout_result(

1921

                    styled(""),

1922

                    vec![hot(Some(1), Some((20.0, 20.0)), None)],

1923

                    vec![p(0.0, 0.0)],

1924

                    Vec::new(),

1925

),

1926

);

1927

1928

            let mut tester = CpuHitTester::new();

1929

            tester.rebuild_from_layout(&results);

1930

            assert_eq!(tester.node_rects_total(), 1);

1931

            // Whatever the clip degenerates to, hit testing must not panic.

1932

            let _ = tester.hit_test(p(10.0, 10.0));

1933

            let _ = tester.hit_test(p(f32::NAN, 0.0));

1934

1935

1936

1937

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

1938

    // compute_node_clip  (numeric)

1939

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

1940

1941

    #[test]

1942

    fn compute_node_clip_without_ancestors_or_dom_clip_is_unclipped() {

1943

        let styled_dom = styled("");

1944

        let nodes = vec![hot(Some(0), Some((10.0, 10.0)), None)];

1945

        let positions: PositionVec = vec![p(0.0, 0.0)];

1946

1947

        assert_eq!(

1948

            compute_node_clip(&styled_dom, &nodes, &positions, 0, p(0.0, 0.0), None),

1949

            None

1950

);

1951

1952

1953

    #[test]

1954

    fn compute_node_clip_out_of_bounds_node_index_does_not_panic() {

1955

        let styled_dom = styled("");

1956

        let nodes: Vec<LayoutNodeHot> = Vec::new();

1957

        let positions: PositionVec = Vec::new();

1958

1959

        for idx in [0_usize, 1, 999, usize::MAX] {

1960

            assert_eq!(

1961

                compute_node_clip(&styled_dom, &nodes, &positions, idx, p(0.0, 0.0), None),

1962

                None

1963

);

1964

            // ...and with a DOM clip it still returns exactly that clip.

1965

            let clip = compute_node_clip(

1966

                &styled_dom,

1967

                &nodes,

1968

                &positions,

1969

                idx,

1970

                p(0.0, 0.0),

1971

                Some(r(1.0, 2.0, 3.0, 4.0)),

1972

);

1973

            assert_eq!(clip, Some(r(1.0, 2.0, 3.0, 4.0)));

1974

1975

1976

1977

    #[test]

1978

    fn compute_node_clip_round_trips_a_dom_clip_when_no_ancestor_clips() {

1979

        // encode == decode: with no clipping ancestor the composite box must come

1980

        // back byte-identical, offset included (the offset is already baked into

1981

        // the placement, so it must NOT be applied twice).

1982

        let styled_dom = styled("");

1983

        let nodes = vec![hot(Some(0), Some((10.0, 10.0)), None)];

1984

        let positions: PositionVec = vec![p(0.0, 0.0)];

1985

        let dom_clip = r(100.0, 200.0, 50.0, 25.0);

1986

1987

        let clip = compute_node_clip(

1988

            &styled_dom,

1989

            &nodes,

1990

            &positions,

1991

0,

1992

            p(100.0, 200.0),

1993

            Some(dom_clip),

1994

1995

        .expect("dom_clip must survive");

1996

1997

        assert_eq!(clip.origin.x, dom_clip.origin.x);

1998

        assert_eq!(clip.origin.y, dom_clip.origin.y);

1999

        assert_eq!(clip.size.width, dom_clip.size.width);

2000

        assert_eq!(clip.size.height, dom_clip.size.height);

2001

2002

2003

    #[test]

2004

    fn compute_node_clip_never_lets_nan_escape_into_the_clip_rect() {

2005

        let styled_dom = styled("");

2006

        let nodes = vec![hot(Some(0), Some((10.0, 10.0)), None)];

2007

        let positions: PositionVec = vec![p(0.0, 0.0)];

2008

2009

        for bad in [f32::NAN, f32::INFINITY, f32::NEG_INFINITY] {

2010

            for dom_clip in [

2011

                r(bad, 0.0, 10.0, 10.0),

2012

                r(0.0, bad, 10.0, 10.0),

2013

                r(0.0, 0.0, bad, 10.0),

2014

                r(0.0, 0.0, 10.0, bad),

2015

                r(bad, bad, bad, bad),

2016

] {

2017

                let clip = compute_node_clip(

2018

                    &styled_dom,

2019

                    &nodes,

2020

                    &positions,

2021

0,

2022

                    p(0.0, 0.0),

2023

                    Some(dom_clip),

2024

2025

                .expect("a dom_clip always yields a clip");

2026

2027

                assert!(

2028

                    clip.origin.x.is_finite()

2029

                        && clip.origin.y.is_finite()

2030

                        && clip.size.width.is_finite()

2031

                        && clip.size.height.is_finite(),

2032

                    "clip {clip:?} from dom_clip {dom_clip:?} must stay finite"

2033

);

2034

                assert!(clip.size.width >= 0.0 && clip.size.height >= 0.0);

2035

                assert!(

2036

                    clip.max_x().is_finite() && clip.max_y().is_finite(),

2037

                    "origin + size must not overflow to inf/NaN"

2038

);

2039

                // point_in_rect over the result must be a real answer, not a NaN

2040

                // comparison that silently drops every event.

2041

                let _ = point_in_rect(p(0.0, 0.0), &clip);

2042

2043

2044

2045

2046

    #[test]

2047

    fn compute_node_clip_clamps_an_infinite_dom_clip_to_clip_unbounded() {

2048

        let styled_dom = styled("");

2049

        let nodes = vec![hot(Some(0), Some((10.0, 10.0)), None)];

2050

        let positions: PositionVec = vec![p(0.0, 0.0)];

2051

2052

        let clip = compute_node_clip(

2053

            &styled_dom,

2054

            &nodes,

2055

            &positions,

2056

0,

2057

            p(0.0, 0.0),

2058

            Some(LogicalRect {

2059

                origin: p(0.0, 0.0),

2060

                size: LogicalSize {

2061

                    width: f32::INFINITY,

2062

                    height: f32::INFINITY,

2063

},

2064

}),

2065

2066

        .expect("a dom_clip always yields a clip");

2067

2068

        assert_eq!(clip.origin.x, 0.0);

2069

        assert_eq!(clip.origin.y, 0.0);

2070

        assert_eq!(clip.size.width, CLIP_UNBOUNDED);

2071

        assert_eq!(clip.size.height, CLIP_UNBOUNDED);

2072

        assert!(point_in_rect(p(1.0e6, 1.0e6), &clip));

2073

2074

2075

    #[test]

2076

    fn compute_node_clip_saturates_a_negative_sized_dom_clip_to_zero_not_negative() {

2077

        let styled_dom = styled("");

2078

        let nodes = vec![hot(Some(0), Some((10.0, 10.0)), None)];

2079

        let positions: PositionVec = vec![p(0.0, 0.0)];

2080

2081

        let clip = compute_node_clip(

2082

            &styled_dom,

2083

            &nodes,

2084

            &positions,

2085

0,

2086

            p(0.0, 0.0),

2087

            Some(r(100.0, 100.0, -50.0, -50.0)),

2088

2089

        .expect("a dom_clip always yields a clip");

2090

2091

        assert_eq!(clip.size.width, 0.0);

2092

        assert_eq!(clip.size.height, 0.0);

2093

        assert!(!point_in_rect(p(100.0, 100.0), &clip));

2094

        assert!(!point_in_rect(p(75.0, 75.0), &clip));

2095

2096

2097

    #[test]

2098

    fn compute_node_clip_intersects_a_clipping_ancestor_with_the_dom_clip() {

2099

        // ancestor div.clip at (10,10) 100x50; dom_clip (0,0) 60x60

2100

        // => intersection (10,10) 50x50

2101

        let styled_dom = styled("div.clip { overflow: hidden; }");

2102

        let nodes = vec![

2103

            hot(Some(0), Some((500.0, 500.0)), None),

2104

            hot(Some(1), Some((100.0, 50.0)), Some(0)),

2105

            hot(Some(2), Some((400.0, 400.0)), Some(1)),

2106

];

2107

        let positions: PositionVec = vec![p(0.0, 0.0), p(10.0, 10.0), p(10.0, 10.0)];

2108

2109

        let clip = compute_node_clip(

2110

            &styled_dom,

2111

            &nodes,

2112

            &positions,

2113

2,

2114

            p(0.0, 0.0),

2115

            Some(r(0.0, 0.0, 60.0, 60.0)),

2116

2117

        .expect("an overflow:hidden ancestor must clip");

2118

2119

        assert_eq!(clip.origin.x, 10.0);

2120

        assert_eq!(clip.origin.y, 10.0);

2121

        assert_eq!(clip.size.width, 50.0);

2122

        assert_eq!(clip.size.height, 50.0);

2123

2124

2125

    #[test]

2126

    fn compute_node_clip_applies_the_offset_to_the_ancestor_box() {

2127

        let styled_dom = styled("div.clip { overflow: hidden; }");

2128

        let nodes = vec![

2129

            hot(Some(0), Some((500.0, 500.0)), None),

2130

            hot(Some(1), Some((100.0, 50.0)), Some(0)),

2131

            hot(Some(2), Some((400.0, 400.0)), Some(1)),

2132

];

2133

        let positions: PositionVec = vec![p(0.0, 0.0), p(10.0, 10.0), p(10.0, 10.0)];

2134

2135

        let clip = compute_node_clip(&styled_dom, &nodes, &positions, 2, p(1000.0, 2000.0), None)

2136

            .expect("an overflow:hidden ancestor must clip");

2137

2138

        assert_eq!(clip.origin.x, 1010.0);

2139

        assert_eq!(clip.origin.y, 2010.0);

2140

        assert_eq!(clip.size.width, 100.0);

2141

        assert_eq!(clip.size.height, 50.0);

2142

2143

2144

    #[test]

2145

    fn compute_node_clip_leaves_the_unclipped_axis_unbounded() {

2146

        // overflow-x: hidden / overflow-y: visible — the y axis must stay

2147

        // unbounded (finite stand-in), not collapse onto the ancestor's box.

2148

        let styled_dom = styled("div.clip { overflow-x: hidden; }");

2149

        let nodes = vec![

2150

            hot(Some(0), Some((500.0, 500.0)), None),

2151

            hot(Some(1), Some((100.0, 50.0)), Some(0)),

2152

            hot(Some(2), Some((400.0, 400.0)), Some(1)),

2153

];

2154

        let positions: PositionVec = vec![p(0.0, 0.0), p(10.0, 10.0), p(10.0, 10.0)];

2155

2156

        let clip = compute_node_clip(&styled_dom, &nodes, &positions, 2, p(0.0, 0.0), None)

2157

            .expect("overflow-x: hidden must clip the x axis");

2158

2159

        assert_eq!(clip.origin.x, 10.0);

2160

        assert_eq!(clip.size.width, 100.0);

2161

        assert_eq!(clip.origin.y, -CLIP_UNBOUNDED);

2162

        assert_eq!(clip.size.height, 2.0 * CLIP_UNBOUNDED);

2163

        assert!(clip.max_y().is_finite());

2164

2165

        // A point far below the ancestor is still inside the clip (y unbounded),

2166

        // but a point to the right of it is not.

2167

        assert!(point_in_rect(p(50.0, 900_000.0), &clip));

2168

        assert!(!point_in_rect(p(500.0, 20.0), &clip));

2169

2170

2171

    #[test]

2172

    fn compute_node_clip_skips_a_clipping_ancestor_that_was_never_laid_out() {

2173

        // used_size: None on the clipping ancestor => nothing to intersect with;

2174

        // it must be skipped rather than contributing a garbage/zero box.

2175

        let styled_dom = styled("div.clip { overflow: hidden; }");

2176

        let nodes = vec![

2177

            hot(Some(0), Some((500.0, 500.0)), None),

2178

            hot(Some(1), None, Some(0)), // clips, but has no used_size

2179

            hot(Some(2), Some((400.0, 400.0)), Some(1)),

2180

];

2181

        let positions: PositionVec = vec![p(0.0, 0.0), p(10.0, 10.0), p(10.0, 10.0)];

2182

2183

        assert_eq!(

2184

            compute_node_clip(&styled_dom, &nodes, &positions, 2, p(0.0, 0.0), None),

2185

            None

2186

);

2187

2188

2189

    #[test]

2190

    fn compute_node_clip_terminates_on_a_parent_cycle() {

2191

        // Two anonymous boxes that are each other's parent. The `guard` counter is

2192

        // the only thing standing between this and an infinite loop inside a

2193

        // hit-test rebuild.

2194

        let styled_dom = styled("");

2195

        let nodes = vec![

2196

            hot(None, Some((10.0, 10.0)), Some(1)),

2197

            hot(None, Some((10.0, 10.0)), Some(0)),

2198

];

2199

        let positions: PositionVec = vec![p(0.0, 0.0), p(0.0, 0.0)];

2200

2201

        assert_eq!(

2202

            compute_node_clip(&styled_dom, &nodes, &positions, 0, p(0.0, 0.0), None),

2203

            None

2204

);

2205

        // The DOM clip still survives the bounded walk.

2206

        assert_eq!(

2207

            compute_node_clip(

2208

                &styled_dom,

2209

                &nodes,

2210

                &positions,

2211

1,

2212

                p(0.0, 0.0),

2213

                Some(r(0.0, 0.0, 5.0, 5.0))

2214

),

2215

            Some(r(0.0, 0.0, 5.0, 5.0))

2216

);

2217

2218

2219

    #[test]

2220

    fn compute_node_clip_terminates_on_a_self_parent_cycle() {

2221

        let styled_dom = styled("");

2222

        let nodes = vec![hot(None, Some((10.0, 10.0)), Some(0))];

2223

        let positions: PositionVec = vec![p(0.0, 0.0)];

2224

2225

        assert_eq!(

2226

            compute_node_clip(&styled_dom, &nodes, &positions, 0, p(0.0, 0.0), None),

2227

            None

2228

);

2229

2230

2231

    #[test]

2232

    fn compute_node_clip_tolerates_a_parent_index_past_the_end_of_the_node_slice() {

2233

        let styled_dom = styled("");

2234

        let nodes = vec![hot(Some(0), Some((10.0, 10.0)), Some(usize::MAX))];

2235

        let positions: PositionVec = vec![p(0.0, 0.0)];

2236

2237

        assert_eq!(

2238

            compute_node_clip(&styled_dom, &nodes, &positions, 0, p(0.0, 0.0), None),

2239

            None

2240

);

2241

2242