Grcov report - compositor.rs

1

use std::collections::HashMap;

2

3

use agg_rust::{blur::stack_blur_rgba32, rendering_buffer::RowAccessor, trans_affine::TransAffine};

4

use azul_core::{

5

    geom::{LogicalPosition, LogicalRect, LogicalSize},

6

    resources::RendererResources,

7

};

8

use azul_css::props::{

9

    basic::{pixel::DEFAULT_FONT_SIZE, ColorU, FontRef},

10

    style::filter::StyleFilter,

11

};

12

13

#[allow(clippy::wildcard_imports)]

14

// widget/render module pulls in the css property/value types it builds with

15

use super::*;

16

use crate::glyph_cache::GlyphCache;

17

18

/// A row-major 3x3 matrix over column vectors `[x; y; 1]`:

19

/// `x' = (m0 x + m1 y + m2) / w`, `y' = (m3 x + m4 y + m5) / w`,

20

/// `w = m6 x + m7 y + m8`. The compositor's per-layer mapping, so a

21

/// perspective (`w` depending on x / y) composes through the layer tree like

22

/// any translation does.

23

pub type Mat3 = [f64; 9];

24

25

/// The identity mapping.

26

pub const MAT3_IDENTITY: Mat3 = [1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0];

27

28

/// `a * b` (apply `b` first, then `a`).

29

#[must_use]

30

222

pub fn mat3_mul(a: &Mat3, b: &Mat3) -> Mat3 {

31

222

    let mut out = [0.0; 9];

32

888

    for r in 0..3 {

33

2664

        for c in 0..3 {

34

1998

            out[r * 3 + c] = a[r * 3] * b[c] + a[r * 3 + 1] * b[3 + c] + a[r * 3 + 2] * b[6 + c];

35

1998

36

37

222

out

38

222

39

40

/// A pure translation.

41

#[must_use]

42

146

pub const fn mat3_translation(tx: f64, ty: f64) -> Mat3 {

43

146

    [1.0, 0.0, tx, 0.0, 1.0, ty, 0.0, 0.0, 1.0]

44

146

45

46

/// Is the third row the trivial `[0 0 1]` (no perspective)?

47

#[must_use]

48

320

pub const fn mat3_is_affine(m: &Mat3) -> bool {

49

320

    m[6] > -1e-12

50

320

        && m[6] < 1e-12

51

320

        && m[7] > -1e-12

52

320

        && m[7] < 1e-12

53

320

        && m[8] > 1.0 - 1e-9

54

320

        && m[8] < 1.0 + 1e-9

55

320

56

57

/// The affine part as agg's `TransAffine` (exact when [`mat3_is_affine`]).

58

#[must_use]

59

320

pub fn mat3_affine_part(m: &Mat3) -> TransAffine {

60

    // agg: x' = x*sx + y*shx + tx; y' = x*shy + y*sy + ty

61

320

    TransAffine::new_custom(m[0], m[3], m[1], m[4], m[2], m[5])

62

320

63

use crate::{

64

    solver3::display_list::{BorderRadius, DisplayList, DisplayListItem, LocalScrollId},

65

    text3::cache::FontManager,

66

};

67

68

const IDENTITY_EPSILON: f32 = 0.0001;

69

70

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

71

// Retained-Mode Compositor — Layer Tree

72

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

73

74

/// Unique identifier for a compositing layer.

75

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

76

pub struct LayerId(pub u64);

77

78

/// Persistent compositor state across frames.

79

///

80

/// Holds a tree of `Layer`s, each with its own pixbuf. On incremental updates

81

/// only damaged layers are re-rendered, and scroll is handled by pixel-shift.

82

#[derive(Debug)]

83

pub struct CompositorState {

84

    /// What the ROOT layer is cleared to every frame: opaque white for an

85

    /// ordinary window, transparent black for a window whose background

86

    /// material is `Transparent` (the OS composites whatever the content

87

    /// leaves at alpha 0 - the desktop shows through a popup's rounded

88

    /// corners). Set through [`Self::set_clear_color`] before rendering.

89

    pub clear_color: [u8; 4],

90

    /// All layers keyed by ID.

91

    pub layers: HashMap<LayerId, Layer>,

92

    /// Root layer of the tree.

93

    pub root_layer: LayerId,

94

    /// Monotonic counter for generating unique `LayerIds`.

95

    next_layer_id: u64,

96

    /// Previous frame's per-node positions, used for damage computation.

97

    pub previous_positions: Vec<LogicalPosition>,

98

99

100

/// A single compositing layer with its own pixel buffer.

101

#[derive(Debug)]

102

pub struct Layer {

103

    pub id: LayerId,

104

    /// Persistent RGBA buffer for this layer's content.

105

    pub pixbuf: AzulPixmap,

106

    /// Position and size in parent layer coordinates.

107

    pub bounds: LogicalRect,

108

    /// Dirty regions that need re-rendering this frame.

109

    pub damage: Vec<LogicalRect>,

110

    /// Child layers in z-order (bottom to top).

111

    pub children: Vec<LayerId>,

112

    /// Current scroll offset (for scroll-frame layers).

113

    pub scroll_offset: (f32, f32),

114

    /// Intersection of the `PushClip` rects open around this layer's `Push*`

115

    /// in the display list — the parent-content-space window this layer must

116

    /// stay inside at composite time (an `overflow: hidden` or border-radius

117

    /// clip WRAPPING a nested layer; radii are ignored for layer clipping).

118

    /// `None` when nothing wraps the layer. Item-level clips inside one

119

    /// layer's own range are the rasterizer's clip stack, not this.

120

    pub static_clip: Option<LogicalRect>,

121

    /// Layer opacity (1.0 = fully opaque).

122

    pub opacity: f32,

123

    /// CSS filters applied at composite time. For a normal filter layer these

124

    /// are applied to the layer's OWN content; for a `backdrop-filter` layer

125

    /// (see `is_backdrop_filter`) they are instead applied to the already-

126

    /// composited backdrop pixels under the layer's bounds.

127

    pub filters: Vec<StyleFilter>,

128

    /// If true, `filters` apply to the backdrop (parent + earlier siblings

129

    /// already in `output`), not to this layer's own content.

130

    pub is_backdrop_filter: bool,

131

    /// CSS transform for this layer (the affine part, layer-local logical

132

    /// units; the translation is scaled to device pixels at composite time).

133

    pub transform: TransAffine,

134

    /// The PERSPECTIVE row of the layer's transform over its z = 0 plane

135

    /// (`[m03, m13, m33]` of the 4x4, logical units): `w = p0 x + p1 y + p2`.

136

    /// `[0, 0, 1]` for every affine transform. A `perspective() rotateX()`

137

    /// tilt lives here — the CPU path used to drop it and composite the

138

    /// affine part only (a tilted map rendered as a squashed rectangle).

139

    pub perspective_row: [f32; 3],

140

    /// Range of display list items [start, end) that render into this layer.

141

    pub display_list_range: (usize, usize),

142

    /// If this layer is a scroll frame, the scroll ID.

143

    pub scroll_id: Option<LocalScrollId>,

144

    /// Whether this layer needs re-compositing onto its parent.

145

    pub composite_dirty: bool,

146

147

148

/// Widest or tallest a compositor layer may be, in device pixels.

149

///

150

/// Nothing a real layout produces comes close — this exists purely so that a

151

/// nonsense extent cannot become an allocation. Chosen to match the usual

152

/// maximum GPU texture dimension, so the CPU path refuses the same sizes the

153

/// GPU path could never hold either.

154

const MAX_LAYER_DIM: u32 = 16_384;

155

156

/// The device-pixel size of a layer's backing pixmap, or `(0, 0)` when the

157

/// layout handed us a size nothing could be drawn at.

158

///

159

/// # Why this is not just `as u32`

160

///

161

/// `f32 as u32` SATURATES in Rust. An infinite (or merely absurd) extent

162

/// silently becomes `u32::MAX`, and the caller then asks `AzulPixmap::new` for

163

/// `u32::MAX * height * 4` bytes — a ~900 GB `vec![255u8; _]` that macOS

164

/// overcommits, touches, and is then killed over. The failure looks nothing

165

/// like its cause: no panic, no allocation error, just a `SIGKILL` seconds

166

/// later with the memory sitting in swap.

167

///

168

/// # Why it is loud

169

///

170

/// A non-finite layer size is ALWAYS a layout bug — there is no legitimate way

171

/// to ask for an infinitely wide box. Clamping quietly would leave that bug in

172

/// place and merely stop it from killing the process, so this panics in debug

173

/// builds and warns once in release, naming the node so the layout that

174

/// produced it can be found. The clamp is the seatbelt, not the fix.

175

/// The DOM node a display-list item came from, for diagnostics only.

176

116

fn node_of(display_list: &DisplayList, index: usize) -> Option<azul_core::dom::NodeId> {

177

116

    display_list.node_mapping.get(index).and_then(|n| *n)

178

116

179

180

126

fn layer_pixel_size(

181

126

    size: LogicalSize,

182

126

    dpi_factor: f32,

183

126

    node: Option<azul_core::dom::NodeId>,

184

126

) -> (u32, u32) {

185

126

    let dw = size.width * dpi_factor;

186

126

    let dh = size.height * dpi_factor;

187

188

126

    if !dw.is_finite() || !dh.is_finite() {

189

7

        report_impossible_layer_size(size, dpi_factor, node, "not finite");

190

7

        return (0, 0);

191

119

192

119

    let over = dw.ceil() > MAX_LAYER_DIM as f32 || dh.ceil() > MAX_LAYER_DIM as f32;

193

119

    if over {

194

1

        report_impossible_layer_size(size, dpi_factor, node, "past MAX_LAYER_DIM");

195

118

196

238

    let px = |v: f32| -> u32 {

197

238

        if v <= 0.0 {

198

17

199

        } else {

200

221

            (v.ceil() as u32).min(MAX_LAYER_DIM)

201

202

238

};

203

119

    (px(dw), px(dh))

204

126

205

206

/// Say — once — that a layer was asked for at a size that cannot be real.

207

///

208

/// `debug_assert` rather than a hard panic so a release build still renders

209

/// (minus the offending layer) instead of dying on a bug the user cannot fix,

210

/// while every test and debug run stops exactly where the bad size was born.

211

8

fn report_impossible_layer_size(

212

8

    size: LogicalSize,

213

8

    dpi_factor: f32,

214

8

    node: Option<azul_core::dom::NodeId>,

215

8

    why: &str,

216

8

) {

217

    #[cfg(feature = "std")]

218

219

        static ANNOUNCE: std::sync::Once = std::sync::Once::new();

220

8

        ANNOUNCE.call_once(|| {

221

1

            eprintln!(

222

1

                "[azul][compositor] layer for node {node:?} requested at {}x{} logical (dpi \

223

1

                 {dpi_factor}) — {why}. This is a LAYOUT bug: no box has an infinite used size. \

224

1

                 The layer is being skipped or clamped so the process survives; the wrong size is \

225

1

                 still wrong.",

226

                size.width, size.height,

227

);

228

1

});

229

230

    // Not under `cfg(test)`: this module's own tests feed the guard infinities

231

    // on purpose to prove it holds, and they must assert on the RESULT rather

232

    // than die inside the thing they are testing.

233

    #[cfg(not(test))]

234

    debug_assert!(

235

        false,

236

        "compositor: layer for node {node:?} at {}x{} logical (dpi {dpi_factor}) is {why}",

237

        size.width, size.height,

238

);

239

8

240

241

/// The `w × h` device-pixel window of `parent` whose top-left sits at

242

/// (`ox`, `oy`) in the parent's pixel space, as RGBA bytes; pixels outside

243

/// the parent are transparent black.

244

///

245

/// The backdrop a plain child layer is

246

/// seeded with (see `render_layers`).

247

#[allow(

248

    clippy::cast_sign_loss,

249

    clippy::cast_possible_wrap,

250

    clippy::cast_possible_truncation

251

)] // bounded pixel/coord cast

252

28

fn backdrop_under(parent: &AzulPixmap, ox: i32, oy: i32, w: u32, h: u32) -> Vec<u8> {

253

28

    let mut out = vec![0u8; (w as usize) * (h as usize) * 4];

254

28

    let pw = parent.width as i32;

255

28

    let ph = parent.height as i32;

256

28

    let src = parent.data();

257

1770

    for y in 0..h as i32 {

258

1770

        let py = oy.saturating_add(y);

259

1770

        if py < 0 || py >= ph {

260

5

            continue;

261

1765

262

        // Overlap of [ox, ox + w) with [0, pw).

263

1765

        let x0 = ox.max(0);

264

1765

        let x1 = ox.saturating_add(w as i32).min(pw);

265

1765

        if x1 <= x0 {

266

            continue;

267

1765

268

1765

        let src_start = ((py * pw + x0) as usize) * 4;

269

1765

        let src_end = ((py * pw + x1) as usize) * 4;

270

1765

        let dst_start = ((y * w as i32) + (x0 - ox)) as usize * 4;

271

1765

        let len = src_end - src_start;

272

1765

        out[dst_start..dst_start + len].copy_from_slice(&src[src_start..src_end]);

273

274

28

out

275

28

276

277

/// Reason a layer was created.

278

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

279

pub enum LayerReason {

280

    /// Root layer (always exists).

281

    Root,

282

    /// Created for a `PushScrollFrame`.

283

    ScrollFrame,

284

    /// Created for a `PushFilter` containing blur.

285

    BlurFilter,

286

    /// Created for a `PushOpacity` with opacity < 1.0.

287

    Opacity,

288

    /// Created for a `PushReferenceFrame` with non-identity transform.

289

    Transform,

290

291

292

/// Plain rect intersection; a disjoint pair yields a ZERO-SIZED rect (clip

293

/// to nothing).

294

3

fn intersect_logical_rects(a: LogicalRect, b: LogicalRect) -> LogicalRect {

295

3

    let x0 = a.origin.x.max(b.origin.x);

296

3

    let y0 = a.origin.y.max(b.origin.y);

297

3

    let x1 = (a.origin.x + a.size.width).min(b.origin.x + b.size.width);

298

3

    let y1 = (a.origin.y + a.size.height).min(b.origin.y + b.size.height);

299

3

    LogicalRect {

300

3

        origin: LogicalPosition { x: x0, y: y0 },

301

3

        size: LogicalSize {

302

3

            width: (x1 - x0).max(0.0),

303

3

            height: (y1 - y0).max(0.0),

304

3

},

305

3

306

3

307

308

impl CompositorState {

309

    /// Create a new compositor with a root layer sized to the viewport.

310

    #[allow(clippy::cast_precision_loss)] // bounded pixel/coord/colour/glyph cast

311

    #[must_use]

312

262

    pub fn new(width: u32, height: u32) -> Self {

313

262

        let root_id = LayerId(0);

314

        // The ROOT layer is the canvas: start it OPAQUE WHITE (the base a

315

        // full repaint clears to), never zeroed transparent black. The

316

        // colorimetric LCD text blend reads destination pixels, so any

317

        // path that touches the root pixbuf before the first

318

        // render_layers (which re-fills it per frame) must find the same

319

        // base a fresh repaint would. Effect layers (opacity / filter /

320

        // transform) stay transparent — they composite; a PLAIN layer is

321

        // seeded with its parent's backdrop in `render_layers`.

322

262

        let mut root_layer = Layer::new(

323

262

            root_id,

324

262

            LogicalRect {

325

262

                origin: LogicalPosition::zero(),

326

262

                size: LogicalSize {

327

262

                    width: width as f32,

328

262

                    height: height as f32,

329

262

},

330

262

},

331

262

            width,

332

262

            height,

333

);

334

262

        root_layer.pixbuf.fill(255, 255, 255, 255);

335

262

        let mut layers = HashMap::new();

336

262

        layers.insert(root_id, root_layer);

337

262

        Self {

338

262

            clear_color: [255, 255, 255, 255],

339

262

            layers,

340

262

            root_layer: root_id,

341

262

            next_layer_id: 1,

342

262

            previous_positions: Vec::new(),

343

262

344

262

345

346

    /// Allocate a new unique layer ID.

347

1101

    pub const fn alloc_layer_id(&mut self) -> LayerId {

348

1101

        let id = LayerId(self.next_layer_id);

349

1101

        self.next_layer_id += 1;

350

1101

id

351

1101

352

353

    /// Read-only peek at the next layer ID counter (for leak probes).

354

    #[must_use]

355

7

    pub const fn next_layer_id_peek(&self) -> u64 {

356

7

        self.next_layer_id

357

7

358

359

    /// Walk the display list and create layers for scroll frames, filters, opacity, transforms.

360

    /// Returns a mapping from display-list item index to the `LayerId` it should render into.

361

    #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)] // bounded pixel/coord/colour/glyph cast

362

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

363

    /// # Panics

364

///

365

    /// Panics if the internal layer stack underflows (a malformed display list).

366

    // single-pass walk over the full display-list opcode set; splitting it would

367

    // only scatter the shared layer-stack state across helpers

368

    #[allow(clippy::cognitive_complexity)]

369

255

    pub fn allocate_layers_from_display_list(

370

255

        &mut self,

371

255

        display_list: &DisplayList,

372

255

        dpi_factor: f32,

373

255

        live_transforms: &HashMap<usize, azul_core::transform::ComputedTransform3D>,

374

255

        live_opacities: &HashMap<usize, f32>,

375

255

) {

376

        // Remove all non-root layers from previous frame

377

255

        let root_id = self.root_layer;

378

260

        self.layers.retain(|id, _| *id == root_id);

379

255

        if let Some(root) = self.layers.get_mut(&root_id) {

380

255

            root.children.clear();

381

255

            root.damage.clear();

382

255

            root.display_list_range = (0, display_list.items.len());

383

255

            root.composite_dirty = true;

384

255

385

386

255

        let mut layer_stack: Vec<LayerId> = vec![root_id];

387

        // The `PushClip`s open at each point of the walk. A layer created

388

        // inside them is windowed by their intersection at composite time —

389

        // the layer-boundary half of clip chaining (the rasterizer's clip

390

        // stack handles items inside one layer).

391

255

        let mut clip_stack: Vec<LogicalRect> = Vec::new();

392

        // One entry per open `PushReferenceFrame`, recording whether it actually

393

        // promoted a layer, so `PopReferenceFrame` pops exactly what was pushed.

394

255

        let mut ref_frame_promoted: Vec<bool> = Vec::new();

395

        // Same recorded pairing for opacity groups: the pop arm used to decide

396

        // by VALUE-testing the top layer (`opacity < 1.0`), which mispairs the

397

        // moment a group's effective opacity passes through exactly 1.0 —

398

        // reachable every time an enter fade completes.

399

255

        let mut opacity_promoted: Vec<bool> = Vec::new();

400

        // Same recorded pairing for scroll frames and filters: a push that

401

        // allocates no layer (zero-sized or EMPTY range) must not let its

402

        // pop remove the parent from the stack.

403

255

        let mut scroll_promoted: Vec<bool> = Vec::new();

404

255

        let mut filter_promoted: Vec<bool> = Vec::new();

405

255

        let mut i = 0;

406

407

3135

        while i < display_list.items.len() {

408

2880

            match &display_list.items[i] {

409

                DisplayListItem::PushScrollFrame {

410

43

                    clip_bounds,

411

43

                    content_size,

412

43

                    scroll_id,

413

..

414

                } => {

415

43

                    let bounds = *clip_bounds.inner();

416

43

                    let (pw, ph) =

417

43

                        layer_pixel_size(bounds.size, dpi_factor, node_of(display_list, i));

418

                    // Find the matching PopScrollFrame FIRST: an EMPTY frame

419

                    // (every empty TextInput's value <p>) must not allocate a

420

                    // layer at all. Its pixbuf was never seeded, cleared or

421

                    // rendered (render_layers skips empty ranges), yet

422

                    // composite still blitted the never-initialized OPAQUE

423

                    // WHITE buffer over the parent - erasing the placeholder

424

                    // text under it on every fully-layered draw (the first

425

                    // frame; damage repaints are flat, which healed it).

426

43

                    let end = find_matching_pop(&display_list.items, i, MatchKind::ScrollFrame);

427

43

                    let created = pw > 0 && ph > 0 && end > i + 1;

428

43

                    scroll_promoted.push(created);

429

43

                    if created {

430

38

                        let new_id = self.alloc_layer_id();

431

38

                        let mut layer = Layer::new(new_id, bounds, pw, ph);

432

38

                        layer.static_clip =

433

38

                            clip_stack.iter().copied().reduce(intersect_logical_rects);

434

38

                        layer.scroll_id = Some(*scroll_id);

435

38

                        layer.display_list_range = (i + 1, end);

436

38

                        self.layers.insert(new_id, layer);

437

                        // Add as child of current parent

438

38

                        let parent_id = *layer_stack.last().unwrap();

439

38

                        if let Some(parent) = self.layers.get_mut(&parent_id) {

440

38

                            parent.children.push(new_id);

441

38

442

38

                        layer_stack.push(new_id);

443

5

444

445

                DisplayListItem::PopScrollFrame => {

446

                    // Pair by recorded decision (see PopOpacity): a frame that

447

                    // allocated no layer must not pop its parent.

448

44

                    if scroll_promoted.pop() == Some(true) && layer_stack.len() > 1 {

449

37

                        layer_stack.pop();

450

37

451

452

                DisplayListItem::PushOpacity {

453

14

                    bounds,

454

14

                    opacity,

455

14

                    opacity_key,

456

                } => {

457

                    // The LIVE value wins over the baked one — an enter/exit

458

                    // fade republishes its opacity every tick without the list

459

                    // being rebuilt, exactly like animated transforms. The

460

                    // baked value is only the fallback for an unkeyed (plain

461

                    // CSS opacity) group.

462

14

                    let effective = opacity_key

463

14

                        .and_then(|k| live_opacities.get(&k.id).copied())

464

14

                        .unwrap_or(*opacity);

465

14

                    let b = *bounds.inner();

466

14

                    let (pw, ph) = layer_pixel_size(b.size, dpi_factor, node_of(display_list, i));

467

14

                    let end = find_matching_pop(&display_list.items, i, MatchKind::Opacity);

468

14

                    let promote = effective < 1.0 && pw > 0 && ph > 0 && end > i + 1;

469

14

                    opacity_promoted.push(promote);

470

14

                    if promote {

471

6

                        let new_id = self.alloc_layer_id();

472

6

                        let mut layer = Layer::new(new_id, b, pw, ph);

473

6

                        layer.static_clip =

474

6

                            clip_stack.iter().copied().reduce(intersect_logical_rects);

475

6

                        layer.opacity = effective;

476

6

                        layer.display_list_range = (i + 1, end);

477

6

                        self.layers.insert(new_id, layer);

478

6

                        let parent_id = *layer_stack.last().unwrap();

479

6

                        if let Some(parent) = self.layers.get_mut(&parent_id) {

480

6

                            parent.children.push(new_id);

481

6

482

6

                        layer_stack.push(new_id);

483

8

484

485

                DisplayListItem::PopOpacity => {

486

                    // Pair by RECORDED DECISION, never by value-testing the top

487

                    // layer — the same fix `PopReferenceFrame` got: an opacity

488

                    // group whose live value has reached exactly 1.0 (a settled

489

                    // fade) allocated nothing, and a value test would pop its

490

                    // PARENT instead.

491

15

                    if opacity_promoted.pop() == Some(true) && layer_stack.len() > 1 {

492

6

                        layer_stack.pop();

493

9

494

495

6

                DisplayListItem::PushFilter { bounds, filters } => {

496

6

                    let has_blur = filters.iter().any(|f| matches!(f, StyleFilter::Blur(_)));

497

6

                    let (pw, ph) = if has_blur {

498

6

                        layer_pixel_size(bounds.inner().size, dpi_factor, node_of(display_list, i))

499

                    } else {

500

                        (0, 0)

501

};

502

6

                    let end = find_matching_pop(&display_list.items, i, MatchKind::Filter);

503

6

                    let promote = has_blur && pw > 0 && ph > 0 && end > i + 1;

504

6

                    filter_promoted.push(promote);

505

6

                    if promote {

506

3

                        let b = *bounds.inner();

507

3

                        let new_id = self.alloc_layer_id();

508

3

                        let mut layer = Layer::new(new_id, b, pw, ph);

509

3

                        layer.static_clip =

510

3

                            clip_stack.iter().copied().reduce(intersect_logical_rects);

511

3

                        layer.filters.clone_from(filters);

512

3

                        layer.display_list_range = (i + 1, end);

513

3

                        self.layers.insert(new_id, layer);

514

3

                        let parent_id = *layer_stack.last().unwrap();

515

3

                        if let Some(parent) = self.layers.get_mut(&parent_id) {

516

3

                            parent.children.push(new_id);

517

3

518

3

                        layer_stack.push(new_id);

519

3

520

521

                DisplayListItem::PopFilter => {

522

                    // Recorded pairing (see PopOpacity) - the old value test

523

                    // on the top layer's filters mispaired nested groups.

524

7

                    if filter_promoted.pop() == Some(true) && layer_stack.len() > 1 {

525

3

                        layer_stack.pop();

526

4

527

528

                DisplayListItem::PushReferenceFrame {

529

54

                    transform_key,

530

54

                    initial_transform,

531

54

                    bounds,

532

                } => {

533

                    // `initial_transform` is the matrix as of display-list BUILD

534

                    // time. A GPU-animated transform (drag, CSS transition, or a

535

                    // diff-driven FLIP) is republished every frame WITHOUT the

536

                    // list being rebuilt, so the live value is authoritative and

537

                    // the baked one is only the fallback for a key nothing has

538

                    // published. Reading the baked matrix here is what made

539

                    // engine-driven transitions invisible: a FLIP starts at

540

                    // identity, so no layer was promoted, and the per-item walk

541

                    // does not apply transforms at all — it only maintains a

542

                    // stack that the layer path consumes.

543

54

                    let m = live_transforms

544

54

                        .get(&transform_key.id)

545

54

                        .map_or(&initial_transform.m, |t| &t.m);

546

54

                    let is_identity = (m[0][0] - 1.0).abs() < IDENTITY_EPSILON

547

54

                        && m[0][1].abs() < IDENTITY_EPSILON

548

54

                        && m[1][0].abs() < IDENTITY_EPSILON

549

54

                        && (m[1][1] - 1.0).abs() < IDENTITY_EPSILON

550

54

                        && m[3][0].abs() < IDENTITY_EPSILON

551

8

                        && m[3][1].abs() < IDENTITY_EPSILON;

552

                    // Record the decision so the matching pop can be exact.

553

54

                    let end = find_matching_pop(&display_list.items, i, MatchKind::ReferenceFrame);

554

54

                    let promote = !is_identity && end > i + 1;

555

54

                    ref_frame_promoted.push(promote);

556

54

                    if promote {

557

50

                        let b = *bounds.inner();

558

50

                        let (pw, ph) =

559

50

                            layer_pixel_size(b.size, dpi_factor, node_of(display_list, i));

560

50

                        let (pw, ph) = (pw.max(1), ph.max(1));

561

50

                        let new_id = self.alloc_layer_id();

562

50

                        let mut layer = Layer::new(new_id, b, pw, ph);

563

50

                        layer.static_clip =

564

50

                            clip_stack.iter().copied().reduce(intersect_logical_rects);

565

50

                        layer.transform = TransAffine::new_custom(

566

50

                            f64::from(m[0][0]),

567

50

                            f64::from(m[0][1]),

568

50

                            f64::from(m[1][0]),

569

50

                            f64::from(m[1][1]),

570

50

                            f64::from(m[3][0]),

571

50

                            f64::from(m[3][1]),

572

50

);

573

50

                        layer.perspective_row = [m[0][3], m[1][3], m[3][3]];

574

50

                        layer.display_list_range = (i + 1, end);

575

50

                        self.layers.insert(new_id, layer);

576

50

                        let parent_id = *layer_stack.last().unwrap();

577

50

                        if let Some(parent) = self.layers.get_mut(&parent_id) {

578

50

                            parent.children.push(new_id);

579

50

580

50

                        layer_stack.push(new_id);

581

4

582

583

                DisplayListItem::PopReferenceFrame => {

584

                    // Pair with the push by RECORDED DECISION, never by asking

585

                    // whether the top layer's transform looks non-identity: an

586

                    // identity frame nested inside a moved one allocates

587

                    // nothing, and a value test would then pop the PARENT and

588

                    // composite everything after it into the wrong layer. A FLIP

589

                    // sits at identity both at rest and at the instant it

590

                    // settles, so that mispairing is reachable in ordinary

591

                    // playback rather than only from a hand-built list.

592

55

                    if ref_frame_promoted.pop() == Some(true) && layer_stack.len() > 1 {

593

50

                        layer_stack.pop();

594

50

595

596

                // `backdrop-filter` (superplan g4): allocate a layer mirroring

597

                // PushFilter, but tagged `is_backdrop_filter` so the compositor

598

                // applies the filter to the *backdrop* (parent + earlier siblings

599

                // already in `output`) rather than to the layer's own content.

600

                // The compositing side reads back the `output` region under the

601

                // layer bounds and runs `apply_layer_filters` on it before

602

                // blitting the content (see `composite_layer_recursive`).

603

3

                DisplayListItem::PushBackdropFilter { bounds, filters } => {

604

3

                    let b = *bounds.inner();

605

3

                    let (pw, ph) = layer_pixel_size(b.size, dpi_factor, node_of(display_list, i));

606

3

                    if pw > 0 && ph > 0 && !filters.is_empty() {

607

2

                        let new_id = self.alloc_layer_id();

608

2

                        let mut layer = Layer::new(new_id, b, pw, ph);

609

2

                        layer.static_clip =

610

2

                            clip_stack.iter().copied().reduce(intersect_logical_rects);

611

2

                        layer.filters.clone_from(filters);

612

2

                        layer.is_backdrop_filter = true;

613

                        // The layer's OWN content may be empty (e.g. an empty

614

                        // div with only `backdrop-filter`). render_layers skips

615

                        // empty display-list ranges, leaving the Layer::new

616

                        // opaque-white pixbuf, which would then be blitted over

617

                        // (and wipe) the filtered backdrop. Start transparent so

618

                        // an empty backdrop-filter element shows the backdrop.

619

2

                        layer.pixbuf.fill(0, 0, 0, 0);

620

2

                        let end =

621

2

                            find_matching_pop(&display_list.items, i, MatchKind::BackdropFilter);

622

2

                        layer.display_list_range = (i + 1, end);

623

2

                        self.layers.insert(new_id, layer);

624

2

                        let parent_id = *layer_stack.last().unwrap();

625

2

                        if let Some(parent) = self.layers.get_mut(&parent_id) {

626

2

                            parent.children.push(new_id);

627

2

628

2

                        layer_stack.push(new_id);

629

1

630

631

                DisplayListItem::PopBackdropFilter => {

632

4

                    if layer_stack.len() > 1 {

633

2

                        let top_id = *layer_stack.last().unwrap();

634

2

                        if let Some(layer) = self.layers.get(&top_id) {

635

2

                            if layer.is_backdrop_filter {

636

2

                                layer_stack.pop();

637

2

638

639

2

640

641

                // `text-shadow` (Push/PopTextShadow) is a text-rasterization

642

                // concern, not a layer boundary, so it is handled in

643

                // `render_single_item`, not here.

644

63

                DisplayListItem::PushClip { bounds, .. } => {

645

63

                    clip_stack.push(*bounds.inner());

646

63

647

63

                DisplayListItem::PopClip => {

648

63

                    clip_stack.pop();

649

63

650

2509

                _ => {}

651

652

2880

            i += 1;

653

654

255

655

656

    /// Compute damage rects from dirty node sets and old/new positions.

657

5

    pub fn compute_damage(

658

5

        &mut self,

659

5

        dirty_nodes: &std::collections::BTreeSet<usize>,

660

5

        old_positions: &[LogicalPosition],

661

5

        new_positions: &[LogicalPosition],

662

5

        calculated_rects: &[LogicalRect],

663

5

) {

664

5

        if dirty_nodes.is_empty() {

665

1

            return;

666

4

667

668

4

        let mut damage_rects = Vec::new();

669

10

        for &node_idx in dirty_nodes {

670

            // Old bounds

671

6

            if node_idx < old_positions.len() && node_idx < calculated_rects.len() {

672

3

                let old_rect = LogicalRect {

673

3

                    origin: old_positions[node_idx],

674

3

                    size: calculated_rects[node_idx].size,

675

3

};

676

3

                damage_rects.push(old_rect);

677

3

678

            // New bounds

679

6

            if node_idx < new_positions.len() && node_idx < calculated_rects.len() {

680

3

                let new_rect = LogicalRect {

681

3

                    origin: new_positions[node_idx],

682

3

                    size: calculated_rects[node_idx].size,

683

3

};

684

3

                damage_rects.push(new_rect);

685

3

686

687

688

        // Distribute damage rects to affected layers

689

4

        for layer in self.layers.values_mut() {

690

10

            for damage in &damage_rects {

691

6

                if let Some(intersection) = rect_intersection(&layer.bounds, damage) {

692

6

                    layer.damage.push(intersection);

693

6

                    layer.composite_dirty = true;

694

6

695

696

697

5

698

699

    /// Render display list items into their respective layer pixbufs.

700

    /// # Panics

701

///

702

    /// Panics if a referenced layer id is not present in the layer map.

703

    /// # Errors

704

///

705

    /// Returns an error string if the layers cannot be composited.

706

225

    pub fn render_layers(

707

225

        &mut self,

708

225

        display_list: &DisplayList,

709

225

        dpi_factor: f32,

710

225

        renderer_resources: &RendererResources,

711

225

        font_manager: &FontManager<FontRef>,

712

225

        glyph_cache: &mut GlyphCache,

713

225

        render_state: &CpuRenderState,

714

225

    ) -> Result<(), String> {

715

225

        let scroll_offsets = &render_state.scroll_offsets;

716

717

        // PARENT-FIRST ORDER. A plain scroll-frame layer is seeded with its

718

        // parent's already-rendered pixels below, so the parent must have

719

        // rendered first; `self.layers` is a HashMap and iterates in no

720

        // order. Walk the tree from the root (children in z-order) and

721

        // remember each layer's parent.

722

225

        let mut order: Vec<LayerId> = Vec::with_capacity(self.layers.len());

723

225

        let mut parent_of: HashMap<LayerId, LayerId> = HashMap::new();

724

225

        let mut stack: Vec<LayerId> = vec![self.root_layer];

725

526

        while let Some(id) = stack.pop() {

726

301

            order.push(id);

727

301

            if let Some(layer) = self.layers.get(&id) {

728

301

                for child in layer.children.iter().rev() {

729

76

                    parent_of.insert(*child, id);

730

76

                    stack.push(*child);

731

76

732

733

734

        // A layer unreachable from the root cannot exist after

735

        // `allocate_layers_from_display_list`, but render it rather than

736

        // drop it if it ever does.

737

301

        for id in self.layers.keys() {

738

301

            if !order.contains(id) {

739

                order.push(*id);

740

301

741

742

743

        // Collect layer IDs, ranges, bounds, scroll_id and child ranges.

744

225

        let layer_ranges: Vec<(

745

225

            LayerId,

746

225

            (usize, usize),

747

225

            LogicalRect,

748

225

            Option<LocalScrollId>,

749

225

            Vec<(usize, usize)>,

750

225

        )> = order

751

225

            .iter()

752

301

            .filter_map(|id| self.layers.get(id).map(|layer| (id, layer)))

753

301

            .map(|(id, layer)| {

754

                // Ranges of this layer's DIRECT children (nested scroll frames /

755

                // opacity / transform groups). They render into their own

756

                // pixbufs, so they must be skipped when rendering this layer's

757

                // range (which, for the root, spans the whole display list).

758

301

                let child_ranges: Vec<(usize, usize)> = layer

759

301

                    .children

760

301

                    .iter()

761

301

                    .filter_map(|cid| self.layers.get(cid).map(|c| c.display_list_range))

762

301

                    .collect();

763

301

764

301

                    *id,

765

301

                    layer.display_list_range,

766

301

                    layer.bounds,

767

301

                    layer.scroll_id,

768

301

                    child_ranges,

769

301

770

301

})

771

225

            .collect();

772

773

        #[cfg(feature = "std")]

774

225

        if std::env::var("AZ_MAP_DEBUG").is_ok() {

775

            for (id, range, bounds, scroll_id, child_ranges) in &layer_ranges {

776

                std::eprintln!(

777

                    "[cpu-layer] render id={:?} range={:?} bounds={:?} scroll={:?} skip={:?} \

778

                     (dl_len={})",

779

id,

780

                    range,

781

                    bounds,

782

                    scroll_id,

783

                    child_ranges,

784

                    display_list.items.len()

785

);

786

787

225

788

789

526

        for (layer_id, range, layer_bounds, scroll_id, child_ranges) in &layer_ranges {

790

301

            let (start, end) = *range;

791

            // An empty range still needs the CLEAR/SEED below: a pixbuf

792

            // starts opaque white and composite blits it regardless. The

793

            // allocator no longer creates empty-range layers, but any other

794

            // source of one must be an identity patch, not a white bar.

795

301

            let has_items = start < end && start < display_list.items.len();

796

797

            // This layer's scroll offset (0 for non-scroll layers). Content inside

798

            // a scroll frame is at absolute coords; the renderer draws at

799

            // `pos - seed`, so folding the scroll offset into the seed shifts the

800

            // frame's content within its own pixbuf. composite_frame blits the

801

            // pixbuf back at `layer.bounds.origin` (NOT scroll_offset), so applying

802

            // it here is the single place — no double offset. (Without this, a full

803

            // repaint while scrolled drew content at offset 0.)

804

301

            let soff = scroll_id

805

301

                .and_then(|id| scroll_offsets.get(&id).copied())

806

301

                .unwrap_or((0.0, 0.0));

807

808

            // THE BACKDROP A LAYER'S CONTENT IS DRAWN OVER.

809

//

810

            // A plain layer — opacity 1, no filter, identity transform; in

811

            // practice every scroll frame — is composited by a verbatim

812

            // copy of its opaque pixels and a blend of the rest, so the

813

            // pixels it did not paint must already BE the parent's pixels.

814

            // They used to be transparent black, and the LCD text sweep

815

            // blends per stripe against whatever is in the destination

816

            // row, then forces the pixel opaque: every glyph inside a scroll

817

            // frame without a local background got dark RGB fringes blended

818

            // against black — the "ghosted subtitle on the first draw"

819

            // (the first frame is the only routinely layered render; later

820

            // repaints are flat and silently fixed it). Seed such a layer

821

            // with the parent's pixels under its bounds instead. Where the

822

            // layer paints nothing the composite is a no-op, where it

823

            // paints the blend sees the true backdrop — full == flat.

824

//

825

            // Opacity / filter / transform layers keep the transparent clear:

826

            // their content must be composited through the effect.

827

301

            let seed_from_parent = *layer_id != self.root_layer

828

76

                && self.layers.get(layer_id).is_some_and(|l| {

829

76

                    l.opacity >= 1.0

830

75

                        && l.filters.is_empty()

831

74

                        && !l.is_backdrop_filter

832

74

                        && l.transform.is_identity(IDENTITY_EPSILON_F64)

833

76

});

834

301

            let seed: Option<Vec<u8>> = if seed_from_parent {

835

28

                let (w, h) = self

836

28

                    .layers

837

28

                    .get(layer_id)

838

28

                    .map_or((0, 0), |l| (l.pixbuf.width, l.pixbuf.height));

839

                // Child-local (0, 0) lands at `bounds.origin` in the parent's

840

                // pixel space — the same placement `composite_layer_recursive`

841

                // uses for an untransformed layer.

842

                // The parent's pixbuf holds the parent's CONTENT: its (0,0)

843

                // is the parent's origin plus its scroll offset in window

844

                // space (items render at `pos - origin - soff`). Sample the

845

                // backdrop in THAT space — absolute coordinates grabbed the

846

                // wrong patch for any layer nested in a non-root layer.

847

28

                parent_of

848

28

                    .get(layer_id)

849

28

                    .and_then(|pid| self.layers.get(pid))

850

28

                    .map(|parent| {

851

28

                        let psoff = parent

852

28

                            .scroll_id

853

28

                            .and_then(|id| scroll_offsets.get(&id).copied())

854

28

                            .unwrap_or((0.0, 0.0));

855

28

                        let ox = ((layer_bounds.origin.x - parent.bounds.origin.x - psoff.0)

856

28

                            * dpi_factor)

857

28

                            .round() as i32;

858

28

                        let oy = ((layer_bounds.origin.y - parent.bounds.origin.y - psoff.1)

859

28

                            * dpi_factor)

860

28

                            .round() as i32;

861

28

                        backdrop_under(&parent.pixbuf, ox, oy, w, h)

862

28

})

863

            } else {

864

273

                None

865

};

866

867

301

            let layer = self.layers.get_mut(layer_id).unwrap();

868

301

            layer.scroll_offset = soff;

869

870

            // Clear the layer pixbuf: the clear colour (white; transparent

871

            // for a transparent window) for the root, the parent's backdrop

872

            // for a plain layer, transparent for an effect layer.

873

301

            if *layer_id == self.root_layer {

874

225

                let [r, g, b, a] = self.clear_color;

875

225

                layer.pixbuf.fill(r, g, b, a);

876

225

            } else if let Some(seed) = seed.filter(|s| s.len() == layer.pixbuf.data().len()) {

877

28

                layer.pixbuf.data_mut().copy_from_slice(&seed);

878

52

            } else {

879

48

                layer.pixbuf.fill(0, 0, 0, 0);

880

48

881

882

            // Seed = layer origin (for pixbuf-local placement) + scroll offset.

883

301

            let offset_x = layer_bounds.origin.x + soff.0;

884

301

            let offset_y = layer_bounds.origin.y + soff.1;

885

301

            if has_items {

886

297

                render_display_list_range(

887

297

                    display_list,

888

297

                    &mut layer.pixbuf,

889

297

                    start,

890

297

                    end.min(display_list.items.len()),

891

297

                    child_ranges,

892

297

                    offset_x,

893

297

                    offset_y,

894

297

                    dpi_factor,

895

297

                    renderer_resources,

896

297

                    font_manager,

897

297

                    glyph_cache,

898

297

                    render_state,

899

)?;

900

4

901

902

903

225

        Ok(())

904

225

905

906

    /// Composite all layers bottom-up into the final output pixmap.

907

    /// Clear the root layer to `color` from now on (see the field).

908

    pub const fn set_clear_color(&mut self, color: [u8; 4]) {

909

        self.clear_color = color;

910

911

912

221

    pub fn composite_frame(&self, output: &mut AzulPixmap, dpi_factor: f32) {

913

        // Start from root layer, with an identity device transform, unclipped.

914

221

        self.composite_layer_recursive(self.root_layer, output, MAT3_IDENTITY, None, dpi_factor);

915

221

916

917

    /// `parent_m` maps the PARENT's local device-pixel space to output

918

    /// device-pixel space — identity for children of the root (the root blits

919

    /// at the origin, untransformed, exactly as before).

920

///

921

    /// A layer's own mapping composes THREE pieces, applied to a layer-local

922

    /// pixel in this order: the layer's live transform (its translation is in

923

    /// LOGICAL units, so it is device-scaled here; the linear part is

924

    /// unit-free), then placement at `bounds.origin`, then the parent chain.

925

    /// Before this, the recursion carried plain offsets and `layer.transform`

926

    /// was NEVER READ at composite time — allocation promoted a transformed

927

    /// layer and stored its live matrix, rendering rasterised its content,

928

    /// and the final blit put the pixels back at the untransformed layout

929

    /// position. That silent drop is why a mid-animation frame with a

930

    /// provably-correct engine state (sampled tx=176, 143, 85, 27 across

931

    /// ticks) produced byte-identical screenshots: every layer of the

932

    /// pipeline agreed except the last one.

933

///

934

    /// Children inherit `this_m`, so a scrollbar or opacity layer INSIDE an

935

    /// animated subtree travels with it.

936

    #[allow(clippy::cast_possible_truncation)] // bounded pixel/coord/colour/glyph cast

937

297

    fn composite_layer_recursive(

938

297

        &self,

939

297

        layer_id: LayerId,

940

297

        output: &mut AzulPixmap,

941

297

        parent_h: Mat3,

942

297

        clip: Option<(i32, i32, i32, i32)>,

943

297

        dpi_factor: f32,

944

297

) {

945

297

        let Some(layer) = self.layers.get(&layer_id) else {

946

            return;

947

};

948

949

        // this_h: layer-local device pixels -> output device pixels, as a

950

        // 3x3 homography over column vectors `[x; y; 1]` so a perspective

951

        // parent carries its foreshortening into every descendant. Affine

952

        // layers (all of them outside a 3D transform) keep a trivial third

953

        // row and take the affine / integer-blit paths below unchanged.

954

297

        let this_h = if layer_id == self.root_layer {

955

            // The root blits at the origin, untransformed — same special case

956

            // the offset-based recursion had.

957

221

            parent_h

958

        } else {

959

76

            let t = &layer.transform;

960

76

            let dpi = f64::from(dpi_factor);

961

            // The layer's live transform with its logical translation scaled

962

            // to device pixels (linear part is unit-free; the perspective

963

            // coefficients multiply coordinates, so they scale by 1/dpi)...

964

76

            let layer_h: Mat3 = [

965

76

                t.sx,

966

76

                t.shx,

967

76

                t.tx * dpi,

968

76

                t.shy,

969

76

                t.sy,

970

76

                t.ty * dpi,

971

76

                f64::from(layer.perspective_row[0]) / dpi,

972

76

                f64::from(layer.perspective_row[1]) / dpi,

973

76

                f64::from(layer.perspective_row[2]),

974

76

];

975

            // ...then placed at bounds.origin, then through the parent chain

976

            // (column-vector matrices: the rightmost factor applies first).

977

76

            let place = mat3_translation(

978

76

                layout_offset_device_px(layer.bounds.origin.x, dpi),

979

76

                layout_offset_device_px(layer.bounds.origin.y, dpi),

980

);

981

76

            mat3_mul(&parent_h, &mat3_mul(&place, &layer_h))

982

};

983

297

        let this_m = mat3_affine_part(&this_h);

984

297

        let is_affine = mat3_is_affine(&this_h);

985

986

        // The clips WRAPPING this layer, recorded at allocation in the

987

        // parent's content space: `parent_h` (the rebased chain handed down)

988

        // is exactly the parent-content -> device mapping, so apply it and

989

        // join the chain. Only tightened when that mapping is a pure

990

        // translation — same policy as the scroll-frame window below.

991

297

        let clip = match layer.static_clip {

992

23

            Some(sc) if layer_id != self.root_layer => {

993

23

                let pm = mat3_affine_part(&parent_h);

994

23

                let translation_only = mat3_is_affine(&parent_h)

995

23

                    && (pm.sx - 1.0).abs() < IDENTITY_EPSILON_F64

996

23

                    && pm.shy.abs() < IDENTITY_EPSILON_F64

997

23

                    && pm.shx.abs() < IDENTITY_EPSILON_F64

998

23

                    && (pm.sy - 1.0).abs() < IDENTITY_EPSILON_F64;

999

23

                if translation_only {

1000

23

                    let dpi = f64::from(dpi_factor);

1001

23

                    let r = (

1002

23

                        (f64::from(sc.origin.x) * dpi + pm.tx).round() as i32,

1003

23

                        (f64::from(sc.origin.y) * dpi + pm.ty).round() as i32,

1004

23

                        (f64::from(sc.origin.x + sc.size.width) * dpi + pm.tx).round() as i32,

1005

23

                        (f64::from(sc.origin.y + sc.size.height) * dpi + pm.ty).round() as i32,

1006

23

);

1007

23

                    Some(clip.map_or(r, |c| {

1008

                        (c.0.max(r.0), c.1.max(r.1), c.2.min(r.2), c.3.min(r.3))

1009

}))

1010

                } else {

1011

                    clip

1012

1013

1014

274

            _ => clip,

1015

};

1016

1017

        // Pure-integer-translation fast path — bit-identical to the old

1018

        // offset blit for every untransformed layer (which is all of them,

1019

        // outside an active animation / drag).

1020

297

        let is_pure_translation = is_affine

1021

297

            && (this_m.sx - 1.0).abs() < IDENTITY_EPSILON_F64

1022

297

            && this_m.shy.abs() < IDENTITY_EPSILON_F64

1023

297

            && this_m.shx.abs() < IDENTITY_EPSILON_F64

1024

297

            && (this_m.sy - 1.0).abs() < IDENTITY_EPSILON_F64

1025

297

            && (this_m.tx - this_m.tx.round()).abs() < 1e-6

1026

259

            && (this_m.ty - this_m.ty.round()).abs() < 1e-6;

1027

297

        let px_x = this_m.tx.round() as i32;

1028

297

        let px_y = this_m.ty.round() as i32;

1029

1030

        // For root layer, just blit directly

1031

297

        if layer_id == self.root_layer {

1032

221

            blit_pixmap(&layer.pixbuf, output, 0, 0, 1.0);

1033

221

        } else if layer.is_backdrop_filter && !layer.filters.is_empty() {

1034

1

            // `backdrop-filter`: the backdrop (parent + earlier siblings) is

1035

1

            // ALREADY composited into `output` at this point (bottom-up

1036

1

            // order). Snapshot the region under the layer's bounds, run the

1037

1

            // filter on that copy, write it back, THEN blit the layer's own

1038

1

            // (unfiltered) content on top. Snapshot placement uses the

1039

1

            // translation of the full mapping, so a backdrop-filter layer

1040

1

            // inside a moved subtree filters the pixels actually under it.

1041

1

            let w = layer.pixbuf.width;

1042

1

            let h = layer.pixbuf.height;

1043

1

            let snap = snapshot_region(output, px_x, px_y, w, h);

1044

1

            let mut backdrop = AzulPixmap {

1045

1

                data: snap.into(),

1046

1

                width: w,

1047

1

                height: h,

1048

1

};

1049

1

            apply_layer_filters(&mut backdrop, &layer.filters, dpi_factor);

1050

1

            write_region(output, &backdrop.data, w, h, px_x, px_y);

1051

1

            blit_pixmap_clipped(&layer.pixbuf, output, px_x, px_y, layer.opacity, clip);

1052

1

        } else {

1053

            // Apply filters at composite time (to the layer's own content).

1054

75

            let src = if layer.filters.is_empty() {

1055

75

                None

1056

            } else {

1057

                let mut filtered = layer.pixbuf.clone_pixmap();

1058

                apply_layer_filters(&mut filtered, &layer.filters, dpi_factor);

1059

                Some(filtered)

1060

};

1061

1062

75

            let src_pixbuf = src.as_ref().unwrap_or(&layer.pixbuf);

1063

75

            if is_pure_translation {

1064

37

                blit_pixmap_clipped(src_pixbuf, output, px_x, px_y, layer.opacity, clip);

1065

45

            } else if is_affine {

1066

38

                blit_pixmap_affine_clipped(src_pixbuf, output, &this_m, layer.opacity, clip);

1067

38

            } else {

1068

                blit_pixmap_projective_clipped(src_pixbuf, output, &this_h, layer.opacity, clip);

1069

1070

1071

1072

        // Composite children in z-order. A child's `bounds.origin` is

1073

        // WINDOW-absolute (every layer's is), so the mapping handed down

1074

        // REBASE-s it into THIS layer's content space: translate by

1075

        // -(this origin + this scroll offset). The root's origin and offset

1076

        // are zero, so direct children of the root keep the absolute

1077

        // placement they always had — but a layer nested in a NON-root layer

1078

        // used to inherit `this_h` (which already places this layer at its

1079

        // absolute origin) and then add its own absolute origin AGAIN: every

1080

        // ancestor origin was double-counted, and a parent's scroll offset

1081

        // never reached it at all. The TextArea widget was the visible case:

1082

        // its inner scroll frame, nested in the demo's scrollable body,

1083

        // painted its placeholder one body-clip-origin lower and to the

1084

        // right of where layout (and hit-testing) put it.

1085

297

        let children: Vec<LayerId> = layer.children.clone();

1086

297

        if children.is_empty() {

1087

227

            return;

1088

70

1089

70

        let dpi = f64::from(dpi_factor);

1090

        // Inverse of `place`, snapped the same way.

1091

70

        let child_base = mat3_mul(

1092

70

            &this_h,

1093

70

            &mat3_translation(

1094

70

                -(layout_offset_device_px(layer.bounds.origin.x, dpi)

1095

70

                    + layout_offset_device_px(layer.scroll_offset.0, dpi)),

1096

70

                -(layout_offset_device_px(layer.bounds.origin.y, dpi)

1097

70

                    + layout_offset_device_px(layer.scroll_offset.1, dpi)),

1098

70

),

1099

);

1100

        // A scroll frame WINDOWS its children: pixels outside its device rect

1101

        // belong to whatever surrounds the frame. Tighten only on the

1102

        // pure-translation path — scroll frames are never transformed in

1103

        // practice, and an approximate tightening under a live transform

1104

        // would clip wrongly rather than loosely.

1105

70

        let child_clip =

1106

70

            if layer_id != self.root_layer && layer.scroll_id.is_some() && is_pure_translation {

1107

2

                let r = (

1108

2

                    px_x,

1109

2

                    px_y,

1110

2

                    px_x.saturating_add(layer.pixbuf.width as i32),

1111

2

                    px_y.saturating_add(layer.pixbuf.height as i32),

1112

2

);

1113

2

                Some(clip.map_or(r, |c| {

1114

                    (c.0.max(r.0), c.1.max(r.1), c.2.min(r.2), c.3.min(r.3))

1115

}))

1116

            } else {

1117

68

                clip

1118

};

1119

146

        for child_id in &children {

1120

76

            self.composite_layer_recursive(*child_id, output, child_base, child_clip, dpi_factor);

1121

76

1122

297

1123

1124

    /// Handle scroll by shifting pixels and re-rendering the exposed strip.

1125

    #[allow(clippy::cast_possible_truncation)] // bounded pixel/coord/colour/glyph cast

1126

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

1127

    /// # Panics

1128

///

1129

    /// Panics if `layer_id` is not present in the layer map.

1130

    /// # Errors

1131

///

1132

    /// Returns an error string if the layer cannot be scrolled.

1133

3

    pub fn scroll_layer(

1134

3

        &mut self,

1135

3

        scroll_id: LocalScrollId,

1136

3

        new_offset: (f32, f32),

1137

3

        display_list: &DisplayList,

1138

3

        dpi_factor: f32,

1139

3

        renderer_resources: &RendererResources,

1140

3

        font_manager: &FontManager<FontRef>,

1141

3

        glyph_cache: &mut GlyphCache,

1142

3

    ) -> Result<(), String> {

1143

        // Find the layer with this scroll_id

1144

3

        let layer_id = self

1145

3

            .layers

1146

3

            .iter()

1147

5

            .find(|(_, l)| l.scroll_id == Some(scroll_id))

1148

3

            .map(|(id, _)| *id);

1149

1150

3

        let Some(layer_id) = layer_id else {

1151

1

            return Ok(()); // No layer for this scroll ID

1152

};

1153

1154

2

        let layer = self.layers.get_mut(&layer_id).unwrap();

1155

2

        let old_offset = layer.scroll_offset;

1156

2

        let dx = new_offset.0 - old_offset.0;

1157

2

        let dy = new_offset.1 - old_offset.1;

1158

1159

2

        if dx.abs() < 0.5 && dy.abs() < 0.5 {

1160

1

            return Ok(());

1161

1

1162

1163

        // Shift pixels

1164

1

        let px_dx = (dx * dpi_factor).round() as i32;

1165

1

        let px_dy = (dy * dpi_factor).round() as i32;

1166

1

        shift_pixbuf(&mut layer.pixbuf, px_dx, px_dy);

1167

1168

        // Compute exposed strips and re-render them.

1169

        // Diagonal scroll produces 2 rects (one vertical strip + one horizontal strip).

1170

1

        let exposed = compute_exposed_rects(&layer.bounds, dx, dy);

1171

2

        for exposed_rect in exposed {

1172

1

            layer.damage.push(exposed_rect);

1173

1

1174

1175

1

        layer.scroll_offset = new_offset;

1176

1

        layer.composite_dirty = true;

1177

1178

        // Re-render damaged regions

1179

1

        let range = layer.display_list_range;

1180

1

        let bounds = layer.bounds;

1181

1

        let offset_x = bounds.origin.x;

1182

1

        let offset_y = bounds.origin.y;

1183

        // Child-layer ranges to skip (rendered separately) — same as render_layers.

1184

1

        let child_ranges: Vec<(usize, usize)> = self

1185

1

            .layers

1186

1

            .get(&layer_id)

1187

1

            .map(|l| {

1188

1

                l.children

1189

1

                    .iter()

1190

1

                    .filter_map(|cid| self.layers.get(cid).map(|c| c.display_list_range))

1191

1

                    .collect()

1192

1

})

1193

1

            .unwrap_or_default();

1194

        // Scroll fast-path: VirtualView content (separate child DOMs) isn't

1195

        // re-composited here — an empty state suffices (VirtualViews inside a

1196

        // scrolling region are an edge case; the next full repaint composites them).

1197

1

        let empty_rs = CpuRenderState::new(ScrollOffsetMap::new());

1198

1

        render_display_list_range(

1199

1

            display_list,

1200

1

            &mut self.layers.get_mut(&layer_id).unwrap().pixbuf,

1201

1

            range.0,

1202

1

            range.1.min(display_list.items.len()),

1203

1

            &child_ranges,

1204

1

            offset_x,

1205

1

            offset_y,

1206

1

            dpi_factor,

1207

1

            renderer_resources,

1208

1

            font_manager,

1209

1

            glyph_cache,

1210

1

            &empty_rs,

1211

)?;

1212

1213

1

        Ok(())

1214

3

1215

1216

1217

impl Layer {

1218

363

    fn new(id: LayerId, bounds: LogicalRect, pixel_width: u32, pixel_height: u32) -> Self {

1219

        Self {

1220

363

id,

1221

363

            pixbuf: AzulPixmap::new(pixel_width.max(1), pixel_height.max(1)).unwrap_or_else(|| {

1222

                AzulPixmap {

1223

                    data: vec![0; 4].into(),

1224

                    width: 1,

1225

                    height: 1,

1226

1227

}),

1228

363

            bounds,

1229

363

            damage: Vec::new(),

1230

363

            children: Vec::new(),

1231

363

            scroll_offset: (0.0, 0.0),

1232

363

            static_clip: None,

1233

            opacity: 1.0,

1234

363

            filters: Vec::new(),

1235

            is_backdrop_filter: false,

1236

363

            transform: TransAffine::new(),

1237

363

            perspective_row: [0.0, 0.0, 1.0],

1238

363

            display_list_range: (0, 0),

1239

363

            scroll_id: None,

1240

            composite_dirty: true,

1241

1242

363

1243

1244

1245

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

1246

// Layer helper types and functions

1247

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

1248

1249

/// Which Push/Pop pair to match.

1250

#[derive(Clone, Copy)]

1251

enum MatchKind {

1252

    ScrollFrame,

1253

    Opacity,

1254

    Filter,

1255

    BackdropFilter,

1256

    ReferenceFrame,

1257

1258

1259

/// Find the matching Pop for a given Push at index `start`.

1260

#[allow(clippy::match_same_arms)] // enum/value mapping/dispatch table: one arm per input variant

1261

                                  // (or cross-type bindings that can't merge)

1262

187

fn find_matching_pop(items: &[DisplayListItem], start: usize, kind: MatchKind) -> usize {

1263

187

    let mut depth = 1u32;

1264

1056

    for (i, item) in items.iter().enumerate().skip(start + 1) {

1265

1056

        match (item, kind) {

1266

6

            (DisplayListItem::PushScrollFrame { .. }, MatchKind::ScrollFrame) => depth += 1,

1267

            (DisplayListItem::PopScrollFrame, MatchKind::ScrollFrame) => {

1268

112

                depth -= 1;

1269

112

                if depth == 0 {

1270

106

                    return i;

1271

6

1272

1273

            (DisplayListItem::PushOpacity { .. }, MatchKind::Opacity) => depth += 1,

1274

            (DisplayListItem::PopOpacity, MatchKind::Opacity) => {

1275

14

                depth -= 1;

1276

14

                if depth == 0 {

1277

14

                    return i;

1278

1279

1280

            (DisplayListItem::PushFilter { .. }, MatchKind::Filter) => depth += 1,

1281

            (DisplayListItem::PopFilter, MatchKind::Filter) => {

1282

6

                depth -= 1;

1283

6

                if depth == 0 {

1284

6

                    return i;

1285

1286

1287

            (DisplayListItem::PushBackdropFilter { .. }, MatchKind::BackdropFilter) => depth += 1,

1288

            (DisplayListItem::PopBackdropFilter, MatchKind::BackdropFilter) => {

1289

2

                depth -= 1;

1290

2

                if depth == 0 {

1291

2

                    return i;

1292

1293

1294

21

            (DisplayListItem::PushReferenceFrame { .. }, MatchKind::ReferenceFrame) => depth += 1,

1295

            (DisplayListItem::PopReferenceFrame, MatchKind::ReferenceFrame) => {

1296

75

                depth -= 1;

1297

75

                if depth == 0 {

1298

54

                    return i;

1299

21

1300

1301

820

            _ => {}

1302

1303

1304

5

    items.len()

1305

187

1306

1307

/// Compute exposed rectangles after a scroll of (dx, dy) in logical coords.

1308

/// Returns 0, 1, or 2 rects: a vertical strip (top/bottom) and/or a horizontal

1309

/// strip (left/right). Diagonal scrolling produces both strips.

1310

8

fn compute_exposed_rects(bounds: &LogicalRect, dx: f32, dy: f32) -> Vec<LogicalRect> {

1311

8

    let w = bounds.size.width;

1312

8

    let h = bounds.size.height;

1313

8

    let mut rects = Vec::new();

1314

1315

    // Vertical exposed strip (full width, covers top or bottom edge)

1316

8

    if dy.abs() > 0.5 {

1317

5

        let strip = if dy > 0.0 {

1318

            // Scrolled down — top strip exposed

1319

4

            LogicalRect {

1320

4

                origin: LogicalPosition {

1321

4

                    x: bounds.origin.x,

1322

4

                    y: bounds.origin.y,

1323

4

},

1324

4

                size: LogicalSize {

1325

4

                    width: w,

1326

4

                    height: dy.min(h),

1327

4

},

1328

4

1329

        } else {

1330

            // Scrolled up — bottom strip exposed

1331

1

            LogicalRect {

1332

1

                origin: LogicalPosition {

1333

1

                    x: bounds.origin.x,

1334

1

                    y: bounds.origin.y + h + dy,

1335

1

},

1336

1

                size: LogicalSize {

1337

1

                    width: w,

1338

1

                    height: (-dy).min(h),

1339

1

},

1340

1

1341

};

1342

5

        rects.push(strip);

1343

3

1344

1345

    // Horizontal exposed strip (full height, covers left or right edge)

1346

8

    if dx.abs() > 0.5 {

1347

1

        let strip = if dx > 0.0 {

1348

            LogicalRect {

1349

                origin: LogicalPosition {

1350

                    x: bounds.origin.x,

1351

                    y: bounds.origin.y,

1352

},

1353

                size: LogicalSize {

1354

                    width: dx.min(w),

1355

                    height: h,

1356

},

1357

1358

        } else {

1359

1

            LogicalRect {

1360

1

                origin: LogicalPosition {

1361

1

                    x: bounds.origin.x + w + dx,

1362

1

                    y: bounds.origin.y,

1363

1

},

1364

1

                size: LogicalSize {

1365

1

                    width: (-dx).min(w),

1366

1

                    height: h,

1367

1

},

1368

1

1369

};

1370

1

        rects.push(strip);

1371

7

1372

1373

8

    rects

1374

8

1375

1376

/// Scroll a frame's clip region by *moving the pixels already on screen* and

1377

/// return the newly-exposed strip(s) (logical coords) that still need painting.

1378

///

1379

/// This is the thin-strip optimisation for scrolling: instead of repainting the

1380

/// whole `clip_bounds` viewport every frame, we `memmove` the pixels that are

1381

/// still visible and only re-rasterise the strip that scrolled into view. For a

1382

/// 30px scroll of a 200×100 viewport that turns ~20k painted px into ~6k.

1383

///

1384

/// Sign convention is the renderer's, NOT the legacy `compute_exposed_rects`:

1385

/// `render_single_item`/`scroll_rect` draw a content item at `position - offset`,

1386

/// so a *positive* `delta` (the user scrolled further down/right) moves on-screen

1387

/// content UP/LEFT. We therefore move the existing pixels UP/LEFT and expose a

1388

/// strip at the trailing (bottom/right) edge. `compute_exposed_rects` assumed the

1389

/// inverse and never matched the renderer — it and `scroll_layer` are dead code.

1390

///

1391

/// Only pixels strictly inside the (clamped) clip rectangle are moved, so the

1392

/// scrollbar, the parent background and sibling content outside the frame are

1393

/// left untouched. Diagonal scroll (both axes in one frame — mobile pan) is

1394

/// handled as TWO strips: the vertical move + horizontal move are separable 1-D

1395

/// passes, so the net effect is a 2-D translation and the exposed region is an

1396

/// L-shape (a full-width top/bottom strip + a full-height left/right strip).

1397

/// The two strips overlap in one corner; that corner is simply repainted twice,

1398

/// which is correct (the caller clears then renders each item once).

1399

///

1400

/// Returns an empty vec when nothing moved, or `[clip_bounds]` when the shift is

1401

/// large enough that the whole viewport is exposed (caller repaints in full).

1402

///

1403

/// NOTE: the move copies *composited* pixels, so a scroll frame whose content is

1404

/// not opaque over its clip can drag whatever showed through. Real scroll

1405

/// containers paint an opaque background or fully cover their box, so this is a

1406

/// known, documented limitation rather than a correctness bug for the common case.

1407

#[allow(

1408

    clippy::cast_possible_truncation,

1409

    clippy::cast_possible_wrap,

1410

    clippy::cast_precision_loss

1411

)] // bounded pixel/coord/colour/glyph cast

1412

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

1413

38

pub fn scroll_shift_region(

1414

38

    pixmap: &mut AzulPixmap,

1415

38

    clip_bounds: &LogicalRect,

1416

38

    delta: (f32, f32),

1417

38

    new_offset: (f32, f32),

1418

38

    dpi_factor: f32,

1419

38

) -> Vec<LogicalRect> {

1420

38

    scroll_shift_region_impl(

1421

38

        pixmap,

1422

38

        clip_bounds,

1423

38

        delta,

1424

38

        new_offset,

1425

38

        dpi_factor,

1426

        false,

1427

        false,

1428

1429

38

1430

1431

/// [`scroll_shift_region`] for a NATIVE target in POOL byte order (#32

1432

/// ARGB8888 commit-swizzle pools): the moved pixels came from a COMMITTED

1433

/// slot and are B,G,R,A; the commit swizzle converts the whole presented

1434

/// clip, so the moved block is converted back to renderer order here —

1435

/// otherwise moved pixels get double-swizzled and scrolled content paints

1436

/// with R and B swapped on the glass.

1437

pub fn scroll_shift_region_pool_order(

1438

    pixmap: &mut AzulPixmap,

1439

    clip_bounds: &LogicalRect,

1440

    delta: (f32, f32),

1441

    new_offset: (f32, f32),

1442

    dpi_factor: f32,

1443

) -> Vec<LogicalRect> {

1444

    scroll_shift_region_impl(

1445

        pixmap,

1446

        clip_bounds,

1447

        delta,

1448

        new_offset,

1449

        dpi_factor,

1450

        false,

1451

        true,

1452

1453

1454

1455

/// [`scroll_shift_region`] with EXACT strips (no 1-px over-cover). The

1456

/// over-cover guards fractional-dpi seams, but for the round-3 patch blit

1457

/// (gated on INTEGRAL physical deltas) it reaches INTO the blit

1458

/// destination — clearing and re-blending one column of carried LCD text,

1459

/// which can never byte-match an unclipped render (the colorimetric blend

1460

/// reads neighbours). Exact strips cover exactly the vacated pixels.

1461

3

pub fn scroll_shift_region_exact(

1462

3

    pixmap: &mut AzulPixmap,

1463

3

    clip_bounds: &LogicalRect,

1464

3

    delta: (f32, f32),

1465

3

    new_offset: (f32, f32),

1466

3

    dpi_factor: f32,

1467

3

) -> Vec<LogicalRect> {

1468

3

    scroll_shift_region_impl(

1469

3

        pixmap,

1470

3

        clip_bounds,

1471

3

        delta,

1472

3

        new_offset,

1473

3

        dpi_factor,

1474

        true,

1475

        false,

1476

1477

3

1478

1479

/// [`scroll_shift_region_exact`] for a pool-order native target — see

1480

/// [`scroll_shift_region_pool_order`].

1481

1

pub fn scroll_shift_region_exact_pool_order(

1482

1

    pixmap: &mut AzulPixmap,

1483

1

    clip_bounds: &LogicalRect,

1484

1

    delta: (f32, f32),

1485

1

    new_offset: (f32, f32),

1486

1

    dpi_factor: f32,

1487

1

) -> Vec<LogicalRect> {

1488

1

    scroll_shift_region_impl(

1489

1

        pixmap,

1490

1

        clip_bounds,

1491

1

        delta,

1492

1

        new_offset,

1493

1

        dpi_factor,

1494

        true,

1495

        true,

1496

1497

1

1498

1499

#[allow(clippy::too_many_lines)]

1500

42

fn scroll_shift_region_impl(

1501

42

    pixmap: &mut AzulPixmap,

1502

42

    clip_bounds: &LogicalRect,

1503

42

    delta: (f32, f32),

1504

42

    new_offset: (f32, f32),

1505

42

    dpi_factor: f32,

1506

42

    exact_strips: bool,

1507

42

    unswizzle_rb_moved: bool,

1508

42

) -> Vec<LogicalRect> {

1509

    // The "just move the pixels" cost of a scroll frame, made visible as a

1510

    // phase: this memmove inside OUR pixmap (plus the strip raster the

1511

    // caller does after) IS the scroll fast path on the CPU backend - there

1512

    // is no OS-compositor layer move below it.

1513

42

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

1514

    // Physical shift = difference of the ROUNDED offsets, not the rounded

1515

    // difference. Rounding each frame's delta independently accumulates up to

1516

    // 0.5px of error per step at fractional dpi (the moved block drifts away

1517

    // from the freshly-rasterised strips, showing internal seams); anchoring

1518

    // both ends to the absolute offset keeps the cumulative error ≤ 1px

1519

    // forever: round(new·dpi) − round(prev·dpi) telescopes across frames.

1520

42

    let prev_offset = (new_offset.0 - delta.0, new_offset.1 - delta.1);

1521

42

    let px_dx =

1522

42

        (new_offset.0 * dpi_factor).round() as i32 - (prev_offset.0 * dpi_factor).round() as i32;

1523

42

    let px_dy =

1524

42

        (new_offset.1 * dpi_factor).round() as i32 - (prev_offset.1 * dpi_factor).round() as i32;

1525

1526

    // Nothing actually moved (sub-pixel jitter rounds to zero).

1527

42

    if px_dx == 0 && px_dy == 0 {

1528

4

        return Vec::new();

1529

38

1530

1531

38

    let pw = pixmap.width() as i32;

1532

38

    let ph = pixmap.height() as i32;

1533

1534

    // Clip rectangle in physical pixels, clamped to the pixmap.

1535

38

    let cx0 = ((clip_bounds.origin.x * dpi_factor).floor() as i32).clamp(0, pw);

1536

38

    let cy0 = ((clip_bounds.origin.y * dpi_factor).floor() as i32).clamp(0, ph);

1537

38

    let cx1 =

1538

38

        (((clip_bounds.origin.x + clip_bounds.size.width) * dpi_factor).ceil() as i32).clamp(0, pw);

1539

38

    let cy1 = (((clip_bounds.origin.y + clip_bounds.size.height) * dpi_factor).ceil() as i32)

1540

38

        .clamp(0, ph);

1541

38

    let region_w = cx1 - cx0;

1542

38

    let region_h = cy1 - cy0;

1543

38

    if region_w <= 0 || region_h <= 0 {

1544

2

        return Vec::new();

1545

36

1546

1547

    // Shift exceeds the region — every pixel is exposed, so skip the memmove and

1548

    // let the caller repaint the whole clip.

1549

36

    if px_dx.abs() >= region_w || px_dy.abs() >= region_h {

1550

16

        return vec![*clip_bounds];

1551

20

1552

1553

    // Dispatch to a specialised mover. The common single-axis cases get a tight

1554

    // 1-D pass; diagonal pan gets a SINGLE-pass 2-D move (each row copied once

1555

    // from its diagonally-offset source) instead of two sequential full passes —

1556

    // half the memory traffic. (no-op is already handled by the early return.)

1557

20

    let stride_px = pw;

1558

20

    let data = pixmap.data_mut();

1559

20

    match (px_dx != 0, px_dy != 0) {

1560

9

        (false, true) => shift_vertical_1d(data, stride_px, cx0, cy0, cx1, cy1, px_dy),

1561

10

        (true, false) => shift_horizontal_1d(data, stride_px, cx0, cy0, cx1, cy1, px_dx),

1562

1

        (true, true) => shift_diagonal_2d(data, stride_px, cx0, cy0, cx1, cy1, px_dx, px_dy),

1563

        (false, false) => {}

1564

1565

1566

    // #32 pool-order targets: convert the shifted region back to renderer

1567

    // byte order (the moved pixels are committed B,G,R,A; the commit swizzle

1568

    // will re-convert the whole presented clip). The exposed strips are

1569

    // repainted fresh right after this returns, so including them here is

1570

    // harmless — the swizzled bytes are overwritten.

1571

20

    if unswizzle_rb_moved {

1572

1

        if std::env::var("AZ_BB_DEBUG").is_ok() {

1573

            eprintln!(

1574

                "[bb] UNSWIZZLE clip px=({cx0},{cy0})..({cx1},{cy1}) delta=({px_dx},{px_dy})"

1575

);

1576

1

1577

32

        for y in cy0..cy1 {

1578

32

            let row = (y * stride_px) as usize;

1579

1024

            for x in cx0..cx1 {

1580

1024

                let o = (row + x as usize) * 4;

1581

1024

                if o + 4 <= data.len() {

1582

1024

                    data.swap(o, o + 2);

1583

1024

1584

1585

1586

19

1587

1588

    // Exposed strip(s) in LOGICAL coords. Over-cover the moving edge by one

1589

    // physical pixel so dpi rounding never leaves a 1px white seam between the

1590

    // moved block and the freshly-painted strip. One strip per moved axis, so

1591

    // diagonal pan yields two (an L-shape, overlapping in one corner).

1592

//

1593

    // Strips are derived from the CLAMPED region (`cx0..cx1`/`cy0..cy1`, the

1594

    // pixels the memmove actually touched), not the raw `clip_bounds`. When

1595

    // the clip extends past the pixmap (container taller than the window),

1596

    // the raw clip's trailing edge is off-screen — a strip placed there

1597

    // clamps to nothing, nothing repaints, and the rows at the WINDOW edge

1598

    // keep their pre-shift content: a stale duplicated band that gets

1599

    // re-dragged on every subsequent scroll.

1600

20

    let cbx = cx0 as f32 / dpi_factor;

1601

20

    let cby = cy0 as f32 / dpi_factor;

1602

20

    let cbw = (cx1 - cx0) as f32 / dpi_factor;

1603

20

    let cbh = (cy1 - cy0) as f32 / dpi_factor;

1604

20

    let mut exposed = Vec::new();

1605

20

    if px_dy != 0 {

1606

10

        let over = if exact_strips { 0.0 } else { 1.0 };

1607

10

        let h_logical = (px_dy.abs() as f32 + over) / dpi_factor;

1608

10

        let h = h_logical.min(cbh);

1609

10

        let y = if px_dy > 0 {

1610

            // bottom strip exposed

1611

10

            cby + cbh - h

1612

        } else {

1613

            // top strip exposed

1614

cby

1615

};

1616

10

        exposed.push(LogicalRect {

1617

10

            origin: LogicalPosition { x: cbx, y },

1618

10

            size: LogicalSize {

1619

10

                width: cbw,

1620

10

                height: h,

1621

10

},

1622

10

});

1623

10

1624

20

    if px_dx != 0 {

1625

11

        let over = if exact_strips { 0.0 } else { 1.0 };

1626

11

        let w_logical = (px_dx.abs() as f32 + over) / dpi_factor;

1627

11

        let w = w_logical.min(cbw);

1628

11

        let x = if px_dx > 0 {

1629

            // right strip exposed

1630

11

            cbx + cbw - w

1631

        } else {

1632

            // left strip exposed

1633

cbx

1634

};

1635

11

        exposed.push(LogicalRect {

1636

11

            origin: LogicalPosition { x, y: cby },

1637

11

            size: LogicalSize {

1638

11

                width: w,

1639

11

                height: cbh,

1640

11

},

1641

11

});

1642

9

1643

20

    exposed

1644

42

1645

1646

// --- scroll_shift_region movers -------------------------------------------

1647

// All three operate in PHYSICAL pixels on the raw RGBA buffer. `cx0..cx1` /

1648

// `cy0..cy1` is the clamped clip region; `stride_px` is the buffer width in

1649

// pixels. They only ever touch bytes inside the clip rectangle. Sign of the

1650

// `px_*` deltas follows the renderer: positive = content moves up/left, so the

1651

// exposed strip is the trailing (bottom/right) edge.

1652

1653

/// Single-axis VERTICAL move: shift whole rows up (`px_dy>0`) or down (`px_dy`<0).

1654

/// Iteration order is chosen so a row read as a source is never already

1655

/// overwritten (src and dst row SETS overlap, so order matters).

1656

#[inline]

1657

#[allow(clippy::cast_sign_loss)] // bounded pixel/coord/colour/glyph cast

1658

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

1659

14

fn shift_vertical_1d(

1660

14

    data: &mut [u8],

1661

14

    stride_px: i32,

1662

14

    cx0: i32,

1663

14

    cy0: i32,

1664

14

    cx1: i32,

1665

14

    cy1: i32,

1666

14

    px_dy: i32,

1667

14

) {

1668

14

    let col_bytes = ((cx1 - cx0) * 4) as usize;

1669

824

    let row_off = |row: i32| ((row * stride_px + cx0) as usize) * 4;

1670

14

    if px_dy > 0 {

1671

        // Content up: dst = src - px_dy (dst < src) → iterate top→bottom.

1672

399

        for dst in cy0..(cy1 - px_dy) {

1673

399

            let s = row_off(dst + px_dy);

1674

399

            data.copy_within(s..s + col_bytes, row_off(dst));

1675

399

1676

    } else {

1677

3

        let amt = -px_dy;

1678

        // Content down: dst = src + amt (dst > src) → iterate bottom→top.

1679

13

        for dst in ((cy0 + amt)..cy1).rev() {

1680

13

            let s = row_off(dst - amt);

1681

13

            data.copy_within(s..s + col_bytes, row_off(dst));

1682

13

1683

1684

14

1685

1686

/// Single-axis HORIZONTAL move: shift each row's pixels left (`px_dx>0`) or right

1687

/// (`px_dx`<0). Source and dest overlap WITHIN a row, so `copy_within`'s memmove

1688

/// semantics handle it directly — no per-row ordering needed.

1689

#[inline]

1690

#[allow(clippy::cast_sign_loss)] // bounded pixel/coord/colour/glyph cast

1691

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

1692

14

fn shift_horizontal_1d(

1693

14

    data: &mut [u8],

1694

14

    stride_px: i32,

1695

14

    cx0: i32,

1696

14

    cy0: i32,

1697

14

    cx1: i32,

1698

14

    cy1: i32,

1699

14

    px_dx: i32,

1700

14

) {

1701

14

    let col_bytes = ((cx1 - cx0) * 4) as usize;

1702

1026

    let row_off = |row: i32| ((row * stride_px + cx0) as usize) * 4;

1703

14

    if px_dx > 0 {

1704

12

        let shift = (px_dx * 4) as usize;

1705

1010

        for row in cy0..cy1 {

1706

1010

            let left = row_off(row);

1707

1010

            data.copy_within(left + shift..left + col_bytes, left);

1708

1010

1709

    } else {

1710

2

        let shift = ((-px_dx) * 4) as usize;

1711

16

        for row in cy0..cy1 {

1712

16

            let left = row_off(row);

1713

16

            data.copy_within(left..left + col_bytes - shift, left + shift);

1714

16

1715

1716

14

1717

1718

/// Diagonal (two-axis) pan in ONE pass: each destination row is copied directly

1719

/// from its diagonally-offset source row, applying the column shift in the same

1720

/// `copy_within`. Because |`px_dy`| ≥ 1, the source and dest rows are always

1721

/// DIFFERENT rows ≥ one stride apart, so the per-copy byte ranges never overlap

1722

/// regardless of the horizontal direction — only the row iteration order (by

1723

/// `px_dy` sign) matters, exactly as in the vertical case. This does the work of

1724

/// the two 1-D passes with half the memory traffic.

1725

#[inline]

1726

#[allow(clippy::cast_sign_loss)] // bounded pixel/coord/colour/glyph cast

1727

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

1728

4

fn shift_diagonal_2d(

1729

4

    data: &mut [u8],

1730

4

    stride_px: i32,

1731

4

    cx0: i32,

1732

4

    cy0: i32,

1733

4

    cx1: i32,

1734

4

    cy1: i32,

1735

4

    px_dx: i32,

1736

4

    px_dy: i32,

1737

4

) {

1738

4

    let span_cols = (cx1 - cx0) - px_dx.abs();

1739

4

    if span_cols <= 0 {

1740

1

        return; // horizontal shift covers the whole region — nothing to keep

1741

3

1742

3

    let len = (span_cols * 4) as usize;

1743

    // Column starts for the kept span: content-left reads from the right, etc.

1744

3

    let (src_col, dst_col) = if px_dx > 0 {

1745

2

        (cx0 + px_dx, cx0)

1746

    } else {

1747

1

        (cx0, cx0 - px_dx)

1748

};

1749

80

    let src_byte = |row: i32| ((row * stride_px + src_col) as usize) * 4;

1750

80

    let dst_byte = |row: i32| ((row * stride_px + dst_col) as usize) * 4;

1751

3

    if px_dy > 0 {

1752

        // Content up: src row = dst + px_dy (below) → iterate top→bottom.

1753

75

        for dst in cy0..(cy1 - px_dy) {

1754

75

            let s = src_byte(dst + px_dy);

1755

75

            data.copy_within(s..s + len, dst_byte(dst));

1756

75

1757

    } else {

1758

1

        let amt = -px_dy;

1759

        // Content down: src row = dst - amt (above) → iterate bottom→top.

1760

5

        for dst in ((cy0 + amt)..cy1).rev() {

1761

5

            let s = src_byte(dst - amt);

1762

5

            data.copy_within(s..s + len, dst_byte(dst));

1763

5

1764

1765

4

1766

1767

/// Decide whether scroll frame `scroll_id` may use the [`scroll_shift_region`]

1768

/// memmove fast path, or whether the caller must full-repaint the clip instead.

1769

///

1770

/// The memmove drags whatever is composited inside the clip. That is only WRONG

1771

/// when transparent gaps in the SCROLLING content let static "backdrop" pixels

1772

/// (painted *behind* the frame) show through and get dragged along. Per the

1773

/// project's aggressive policy: take the fast path UNLESS that exact condition is

1774

/// proven — i.e. fall back ONLY when (a) something is painted behind the frame

1775

/// within the clip AND (b) the scrolling content does not opaquely cover the clip.

1776

///

1777

/// `scroll_offset` is the frame's current offset and `prev_offset` the offset

1778

/// the pixels being moved were rendered at; both are used to project the

1779

/// content's opaque fills (stored at content coords) into viewport space for

1780

/// the coverage test — coverage must hold at BOTH offsets, since the memmove

1781

/// drags pixels that were composited at the OLD offset. A scroll frame over

1782

/// nothing-but-the-clear-color is always eligible (no backdrop to drag).

1783

/// Returns `true` when there is no such frame (nothing to do).

1784

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

1785

#[allow(clippy::match_same_arms)]

1786

// enum/value mapping/dispatch table: one arm per input variant (or cross-type bindings that can't

1787

// merge)

1788

#[must_use]

1789

36

pub fn scroll_fast_path_eligible(

1790

36

    display_list: &DisplayList,

1791

36

    scroll_id: LocalScrollId,

1792

36

    clip_bounds: &LogicalRect,

1793

36

    scroll_offset: (f32, f32),

1794

36

    prev_offset: (f32, f32),

1795

36

) -> bool {

1796

36

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

1797

1798

    // Locate the frame's content range [start+1, end).

1799

117

    let start = display_list.items.iter().position(|it| {

1800

36

        matches!(it, DisplayListItem::PushScrollFrame { scroll_id: sid, .. } if *sid == scroll_id)

1801

117

});

1802

36

    let Some(start) = start else {

1803

1

        return true; // no frame for this id → nothing to shift

1804

};

1805

35

    let end = find_matching_pop(&display_list.items, start, MatchKind::ScrollFrame)

1806

35

        .min(display_list.items.len());

1807

1808

    // NESTED frame → ineligible. An inner frame's clip_bounds are the OUTER

1809

    // frame's content coords: with the outer frame scrolled, the memmove

1810

    // would shift a region displaced from the real on-screen clip by the

1811

    // outer offset. Conservative full-clip repaint instead.

1812

35

    let mut depth = 0i32;

1813

94

    for it in &display_list.items[..start] {

1814

82

        match it {

1815

1

            DisplayListItem::PushScrollFrame { .. } => depth += 1,

1816

            DisplayListItem::PopScrollFrame => depth -= 1,

1817

81

            _ => {}

1818

1819

1820

35

    if depth > 0 {

1821

1

        return false;

1822

34

1823

1824

    // NOTE on overlays: anything painted AFTER the frame that overlaps the

1825

    // clip (the frame's own scrollbar, an open dropdown, a tooltip) gets

1826

    // dragged by the memmove. That does NOT make the frame ineligible — the

1827

    // caller repaints those regions after the shift via

1828

    // [`overlay_rects_after_frame`] (a scrollbar would otherwise disable the

1829

    // fast path for every scroll container).

1830

1831

    // (a) Best case: the SCROLLING content opaquely covers the clip (projected

1832

    // into viewport space by the scroll offset — at BOTH the old offset, where

1833

    // the dragged pixels were rendered, and the new one). Then nothing behind

1834

    // can ever show through, so the shift is always safe.

1835

62

    let covered_at = |off: (f32, f32)| {

1836

62

        let fills: Vec<LogicalRect> = display_list.items[start + 1..end]

1837

62

            .iter()

1838

62

            .filter_map(opaque_fill_rect)

1839

62

            .map(|r| LogicalRect {

1840

262

                origin: LogicalPosition {

1841

262

                    x: r.origin.x - off.0,

1842

262

                    y: r.origin.y - off.1,

1843

262

},

1844

262

                size: r.size,

1845

262

})

1846

62

            .collect();

1847

62

        rect_covered_by(clip_bounds, &fills)

1848

62

};

1849

34

    if covered_at(scroll_offset) && covered_at(prev_offset) {

1850

27

        return true;

1851

7

1852

1853

    // (b) Content has gaps. The drag is only VISIBLE if a NON-UNIFORM backdrop

1854

    // shows through. Scan items behind the frame for SIGNIFICANT backdrop fills

1855

    // (≥10% of the clip) — borders, text, shadows, thin/small decorations smear

1856

    // imperceptibly and are ignored (aggressive policy: fall back only on a

1857

    // proven artifact). Classify each significant backdrop item:

1858

    //   - flat opaque Rect  → track its colour

1859

    //   - Image / gradient  → non-uniform → not safe

1860

    // Then: no significant backdrop → safe (only the clear behind); a single flat

1861

    // colour that COVERS the clip → drags invisibly → safe; mixed colours, a

1862

    // partial cover, or any non-uniform fill → full-repaint.

1863

7

    let clip_area = (clip_bounds.size.width * clip_bounds.size.height).max(1.0);

1864

7

    let mut backdrop_fills: Vec<LogicalRect> = Vec::new();

1865

7

    let mut backdrop_color: Option<ColorU> = None;

1866

7

    for it in &display_list.items[..start] {

1867

6

        if it.is_state_management() {

1868

            continue;

1869

6

1870

6

        let b = match it.bounds() {

1871

6

            Some(b) if rects_overlap_or_adjacent(&b, clip_bounds, 0.0) => b,

1872

            _ => continue,

1873

};

1874

        // Area of this item within the clip; ignore negligible coverage.

1875

6

        let ix = b.origin.x.max(clip_bounds.origin.x);

1876

6

        let iy = b.origin.y.max(clip_bounds.origin.y);

1877

6

        let ix1 = (b.origin.x + b.size.width).min(clip_bounds.origin.x + clip_bounds.size.width);

1878

6

        let iy1 = (b.origin.y + b.size.height).min(clip_bounds.origin.y + clip_bounds.size.height);

1879

6

        let isect_area = ((ix1 - ix).max(0.0)) * ((iy1 - iy).max(0.0));

1880

6

        if isect_area < clip_area * 0.10 {

1881

            continue; // negligible — thin border / small decoration

1882

6

1883

6

        match it {

1884

            DisplayListItem::Rect {

1885

6

                color,

1886

6

                border_radius,

1887

..

1888

6

            } if color.a == 255 && border_radius.is_zero() => {

1889

1

                match backdrop_color {

1890

5

                    None => backdrop_color = Some(*color),

1891

1

                    Some(prev) if prev == *color => {}

1892

1

                    Some(_) => return false, // ≥2 distinct backdrop colours → visible

1893

1894

5

                backdrop_fills.push(b);

1895

1896

            DisplayListItem::Rect { .. } => {} // translucent / rounded — let it drag

1897

            DisplayListItem::Image { .. }

1898

            | DisplayListItem::LinearGradient { .. }

1899

            | DisplayListItem::RadialGradient { .. }

1900

            | DisplayListItem::ConicGradient { .. } => return false, // non-uniform fill

1901

            _ => {}                            // border/text/shadow/scrollbar etc. — negligible

1902

1903

1904

6

    if backdrop_fills.is_empty() {

1905

2

        return true; // only the clear (or negligible decoration) behind

1906

4

1907

    // Single flat colour: safe only if it fills the whole clip (else its edge

1908

    // against the clear would drag visibly).

1909

4

    rect_covered_by(clip_bounds, &backdrop_fills)

1910

36

1911

1912

/// Result of diffing the GPU-animated values between two frames.

1913

#[derive(Debug, Default)]

1914

pub struct GpuValueDamage {

1915

    /// Regions to repaint (scrollbar bounds whose thumb/opacity value changed).

1916

    pub rects: Vec<LogicalRect>,

1917

    /// A changed transform is bound to a `PushReferenceFrame` (drag / CSS

1918

    /// transform animation): the moved CONTENT's extent isn't derivable from

1919

    /// the item alone, so the caller must full-repaint.

1920

    pub needs_full: bool,

1921

1922

1923

/// Diff the GPU value maps of two frames and damage the items BOUND to the

1924

/// changed keys.

1925

///

1926

/// Scrollbar thumb position, scrollbar fade opacity, and drag/CSS transforms

1927

/// live in the GPU value cache; display-list items only carry the KEYS, so

1928

/// they compare `is_visually_equal` while the pixels must change. Without

1929

/// this channel, the `ScrollBarStyled` equality arm would freeze the thumb

1930

/// (missed damage); with it, an idle window reaches `FrameDamage::None` even

1931

/// with scrollbars present.

1932

#[allow(clippy::implicit_hasher)] // internal call sites all use std hasher

1933

#[must_use]

1934

16769

pub fn gpu_value_damage(

1935

16769

    display_list: &DisplayList,

1936

16769

    old_transforms: &HashMap<usize, azul_core::transform::ComputedTransform3D>,

1937

16769

    old_opacities: &HashMap<usize, f32>,

1938

16769

    new_transforms: &HashMap<usize, azul_core::transform::ComputedTransform3D>,

1939

16769

    new_opacities: &HashMap<usize, f32>,

1940

16769

) -> GpuValueDamage {

1941

    use std::collections::HashSet;

1942

1943

16769

    let mut changed_t: HashSet<usize> = HashSet::new();

1944

33314

    for (k, v) in new_transforms {

1945

16545

        if old_transforms.get(k) != Some(v) {

1946

88

            changed_t.insert(*k);

1947

16458

1948

1949

16769

    for k in old_transforms.keys() {

1950

16520

        if !new_transforms.contains_key(k) {

1951

10

            changed_t.insert(*k);

1952

16510

1953

1954

16769

    let mut changed_o: HashSet<usize> = HashSet::new();

1955

33304

    for (k, v) in new_opacities {

1956

16535

        if old_opacities.get(k) != Some(v) {

1957

46

            changed_o.insert(*k);

1958

16490

1959

1960

16769

    for k in old_opacities.keys() {

1961

16510

        if !new_opacities.contains_key(k) {

1962

10

            changed_o.insert(*k);

1963

16500

1964

1965

1966

16769

    let mut out = GpuValueDamage::default();

1967

16769

    if changed_t.is_empty() && changed_o.is_empty() {

1968

16682

        return out;

1969

87

1970

1971

    // A moved reference frame damages its CONTENT at both the old and the

1972

    // new position. The content extent is the union of the visual bounds of

1973

    // everything down to the matching Pop (nested frames' pixels ride along),

1974

    // transformed by each matrix ABOUT THE FRAME ORIGIN — the same convention

1975

    // the compositor renders with. Only a non-affine matrix (perspective) is

1976

    // genuinely unknowable and keeps the full-repaint fallback; the previous

1977

    // blanket needs_full made EVERY spring/move tick a full-frame repaint.

1978

124

    fn affine_rect_about(

1979

124

        m: &azul_core::transform::ComputedTransform3D,

1980

124

        origin: LogicalPosition,

1981

124

        r: LogicalRect,

1982

124

    ) -> Option<LogicalRect> {

1983

124

        let mm = &m.m;

1984

124

        let affine = mm[0][2] == 0.0

1985

124

            && mm[0][3] == 0.0

1986

124

            && mm[1][2] == 0.0

1987

124

            && mm[1][3] == 0.0

1988

124

            && (mm[3][3] - 1.0).abs() < f32::EPSILON;

1989

124

        if !affine {

1990

            return None;

1991

124

1992

124

        let (mut min_x, mut min_y) = (f32::MAX, f32::MAX);

1993

124

        let (mut max_x, mut max_y) = (f32::MIN, f32::MIN);

1994

496

        for (cx, cy) in [

1995

124

            (r.origin.x, r.origin.y),

1996

124

            (r.origin.x + r.size.width, r.origin.y),

1997

124

            (r.origin.x, r.origin.y + r.size.height),

1998

124

            (r.origin.x + r.size.width, r.origin.y + r.size.height),

1999

496

] {

2000

496

            let (px, py) = (cx - origin.x, cy - origin.y);

2001

496

            let x = px * mm[0][0] + py * mm[1][0] + mm[3][0] + origin.x;

2002

496

            let y = px * mm[0][1] + py * mm[1][1] + mm[3][1] + origin.y;

2003

496

            min_x = min_x.min(x);

2004

496

            min_y = min_y.min(y);

2005

496

            max_x = max_x.max(x);

2006

496

            max_y = max_y.max(y);

2007

496

2008

124

        Some(LogicalRect::new(

2009

124

            LogicalPosition::new(min_x, min_y),

2010

124

            LogicalSize::new(max_x - min_x, max_y - min_y),

2011

124

))

2012

124

2013

2014

87

    let identity = azul_core::transform::ComputedTransform3D {

2015

87

        m: [

2016

87

            [1.0, 0.0, 0.0, 0.0],

2017

87

            [0.0, 1.0, 0.0, 0.0],

2018

87

            [0.0, 0.0, 1.0, 0.0],

2019

87

            [0.0, 0.0, 0.0, 1.0],

2020

87

],

2021

87

};

2022

87

    let items = &display_list.items;

2023

1369

    for (idx, item) in items.iter().enumerate() {

2024

70

        match item {

2025

            DisplayListItem::PushReferenceFrame {

2026

70

                transform_key,

2027

70

                bounds,

2028

..

2029

70

            } if changed_t.contains(&transform_key.id) => {

2030

                // Content extent: union to the matching Pop.

2031

62

                let mut depth = 0usize;

2032

62

                let mut content: Option<LogicalRect> = None;

2033

565

                for it in &items[idx..] {

2034

565

                    match it {

2035

83

                        DisplayListItem::PushReferenceFrame { .. } => depth += 1,

2036

                        DisplayListItem::PopReferenceFrame => {

2037

83

                            depth = depth.saturating_sub(1);

2038

83

                            if depth == 0 {

2039

62

                                break;

2040

21

2041

2042

399

                        _ => {}

2043

2044

503

                    if let Some(b) = it.visual_bounds() {

2045

481

                        content = Some(content.map_or(b, |c| {

2046

419

                            let x0 = c.origin.x.min(b.origin.x);

2047

419

                            let y0 = c.origin.y.min(b.origin.y);

2048

419

                            let x1 = (c.origin.x + c.size.width).max(b.origin.x + b.size.width);

2049

419

                            let y1 = (c.origin.y + c.size.height).max(b.origin.y + b.size.height);

2050

419

                            LogicalRect::new(

2051

419

                                LogicalPosition::new(x0, y0),

2052

419

                                LogicalSize::new(x1 - x0, y1 - y0),

2053

2054

419

                        }));

2055

22

2056

2057

62

                let content = content.unwrap_or_else(|| *bounds.inner());

2058

62

                let old_m = old_transforms.get(&transform_key.id).unwrap_or(&identity);

2059

62

                let new_m = new_transforms.get(&transform_key.id).unwrap_or(&identity);

2060

                match (

2061

62

                    affine_rect_about(old_m, bounds.inner().origin, content),

2062

62

                    affine_rect_about(new_m, bounds.inner().origin, content),

2063

) {

2064

62

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

2065

62

                        out.rects.push(a);

2066

62

                        out.rects.push(b);

2067

62

2068

                    _ => out.needs_full = true,

2069

2070

2071

35

            DisplayListItem::ScrollBarStyled { info } => {

2072

35

                let thumb_moved = info

2073

35

                    .thumb_transform_key

2074

35

                    .is_some_and(|k| changed_t.contains(&k.id));

2075

35

                let faded = info.opacity_key.is_some_and(|k| changed_o.contains(&k.id));

2076

35

                if thumb_moved || faded {

2077

35

                    // The whole bar bounds cover the thumb's old AND new

2078

35

                    // position — precise and cheap.

2079

35

                    out.rects.push(info.bounds.0);

2080

35

2081

2082

            DisplayListItem::PushOpacity {

2083

                bounds,

2084

                opacity_key: Some(k),

2085

..

2086

            } => {

2087

                // A faded group repaints inside its own bounds — precise,

2088

                // unlike a moved reference frame whose content extent is

2089

                // unknowable from the item.

2090

                if changed_o.contains(&k.id) {

2091

                    out.rects.push(*bounds.inner());

2092

2093

2094

1272

            _ => {}

2095

2096

2097

    // A changed key bound to nothing in THIS display list (another DOM's

2098

    // scrollbar, a stale key) is ignored — it cannot affect these pixels.

2099

87

out

2100

16769

2101

2102

/// Which scroll frames moved since the previous frame, with their clips

2103

/// PROJECTED INTO VIEWPORT SPACE — the one shared collector for the shell

2104

/// and the e2e twin (they used to carry identical copies).

2105

///

2106

/// `PushScrollFrame.clip_bounds` is the frame's clip in its PARENT's content

2107

/// space (`get_paint_rect` applies no scroll). Damage rects are consumed in

2108

/// viewport space, so a frame NESTED inside a scrolled ancestor — the

2109

/// `TextInput`'s value `<p>` inside a scrolled page column — had its fallback

2110

/// "repaint the whole clip" rect land `outer offset` pixels away from the

2111

/// field: the field kept its old horizontal offset while a correctly placed

2112

/// caret strip beside it rendered at the new one (the seam, 2026-08-31).

2113

/// The walk keeps an offset stack of the enclosing frames' CURRENT offsets

2114

/// and subtracts it, so top-level frames are unchanged and nested ones land

2115

/// where they are on screen. Returns `(scroll_id, clip, delta, offset)`.

2116

#[must_use]

2117

16783

pub fn collect_scroll_shifts(

2118

16783

    display_list: &DisplayList,

2119

16783

    scroll_offsets: &ScrollOffsetMap,

2120

16783

    previous_scroll_offsets: &ScrollOffsetMap,

2121

16783

    dpi_factor: f32,

2122

16783

) -> Vec<(LocalScrollId, LogicalRect, (f32, f32), (f32, f32))> {

2123

16793

    let moved = |id: &LocalScrollId, offset: &(f32, f32)| -> Option<(f32, f32)> {

2124

16484

        let prev = previous_scroll_offsets

2125

16484

            .get(id)

2126

16484

            .copied()

2127

16484

            .unwrap_or((0.0, 0.0));

2128

16484

        let delta = (offset.0 - prev.0, offset.1 - prev.1);

2129

        // Threshold in PHYSICAL pixels: a delta that moves the content by at

2130

        // least half a device pixel must repaint (at dpi=2 a 0.3-logical

2131

        // wheel step is already a visible 0.6-device-px move).

2132

16484

        ((delta.0 * dpi_factor).abs() > 0.5 || (delta.1 * dpi_factor).abs() > 0.5).then_some(delta)

2133

16484

};

2134

16783

    let mut out = Vec::new();

2135

16783

    let mut stack: Vec<(f32, f32)> = Vec::new();

2136

16783

    let mut acc = (0.0f32, 0.0f32);

2137

316825

    for item in &display_list.items {

2138

300042

        match item {

2139

            DisplayListItem::PushScrollFrame {

2140

16516

                clip_bounds,

2141

16516

                scroll_id,

2142

..

2143

            } => {

2144

16516

                let offset = scroll_offsets.get(scroll_id).copied().unwrap_or((0.0, 0.0));

2145

16516

                if let Some(delta) = scroll_offsets

2146

16516

                    .get(scroll_id)

2147

16516

                    .and_then(|o| moved(scroll_id, o))

2148

34

2149

34

                    let mut clip = *clip_bounds.inner();

2150

34

                    clip.origin.x -= acc.0;

2151

34

                    clip.origin.y -= acc.1;

2152

34

                    out.push((*scroll_id, clip, delta, offset));

2153

16482

2154

16516

                stack.push(offset);

2155

16516

                acc.0 += offset.0;

2156

16516

                acc.1 += offset.1;

2157

2158

            DisplayListItem::PopScrollFrame => {

2159

16516

                if let Some(off) = stack.pop() {

2160

16516

                    acc.0 -= off.0;

2161

16516

                    acc.1 -= off.1;

2162

16516

2163

2164

267010

            _ => {}

2165

2166

2167

16783

out

2168

16783

2169

2170

/// The complete FAST-PATH damage recipe for one scrolled frame, shared by

2171

/// the shell (`headless/mod.rs`) and the e2e twin (`e2e/cpu_backend.rs`) so a

2172

/// damage rule can never land on one side only — the scrollbar snap-back

2173

/// ghost trail (2026-08-29) was exactly such a one-sided fix: the twin

2174

/// repainted the dragged overlay ghost, the shell did not.

2175

///

2176

/// Eligibility is checked at the PREVIOUS offset too (the pixels being

2177

/// dragged were composited there). On the fast path the region is memmoved,

2178

/// the exposed strips become damage, and every overlay composited over the

2179

/// frame (its own scrollbar, an open dropdown) is repainted at BOTH its

2180

/// correct position and where its dragged ghost landed (`origin - delta`) —

2181

/// an overlay that does not span the scroll axis (the vertical scrollbar

2182

/// during a horizontal pan) otherwise keeps a delta-wide stale copy per

2183

/// frame. Ineligible frames repaint their whole clip.

2184

#[derive(Debug)]

2185

pub struct ScrollShiftOutcome {

2186

    /// Rects to re-raster.

2187

    pub damage: Vec<LogicalRect>,

2188

    /// Rects to present even though they were not re-rastered (the whole

2189

    /// moved clip on the fast path).

2190

    pub present_extra: Vec<LogicalRect>,

2191

2192

2193

/// See [`ScrollShiftOutcome`]. `pool_order` selects the commit-swizzle mover

2194

/// for native ARGB pools ([`scroll_shift_region_pool_order`]).

2195

#[allow(clippy::too_many_arguments)]

2196

24

pub fn execute_scroll_shift(

2197

24

    pixmap: &mut AzulPixmap,

2198

24

    display_list: &DisplayList,

2199

24

    scroll_id: LocalScrollId,

2200

24

    clip: &LogicalRect,

2201

24

    delta: (f32, f32),

2202

24

    offset: (f32, f32),

2203

24

    dpi_factor: f32,

2204

24

    pool_order: bool,

2205

24

) -> ScrollShiftOutcome {

2206

24

    let mut damage = Vec::new();

2207

24

    let mut present_extra = Vec::new();

2208

24

    let prev_offset = (offset.0 - delta.0, offset.1 - delta.1);

2209

24

    if scroll_fast_path_eligible(display_list, scroll_id, clip, offset, prev_offset) {

2210

24

        let strips = if pool_order {

2211

            scroll_shift_region_pool_order(pixmap, clip, delta, offset, dpi_factor)

2212

        } else {

2213

24

            scroll_shift_region(pixmap, clip, delta, offset, dpi_factor)

2214

};

2215

        // Empty strips = the delta rounded to ZERO physical pixels: no

2216

        // memmove ran and (pool-order targets) NOTHING was unswizzled. The

2217

        // clip must then stay OUT of present_extra - on the in-place

2218

        // commit-swizzle path an extra rect is not "harmless over-coverage"

2219

        // but a byte swap of pixels nobody wrote: AzWriter's caret blink

2220

        // carried a stationary scroll clip here every frame, and each

2221

        // present TOGGLED the whole document area R<->B (blue UI one frame,

2222

        // brown the next - KDE Wayland session, 2026-08-29). The swizzle

2223

        // contract: present_extra covers exactly what the shifter

2224

        // unswizzled, never more.

2225

24

        let moved = !strips.is_empty();

2226

24

        damage.extend(strips);

2227

24

        if moved {

2228

24

            for g in overlay_rects_after_frame(display_list, scroll_id, clip) {

2229

10

                damage.push(g);

2230

10

                let mut ghost = g;

2231

10

                ghost.origin.x -= delta.0;

2232

10

                ghost.origin.y -= delta.1;

2233

10

                damage.push(ghost);

2234

10

2235

24

            present_extra.push(*clip);

2236

2237

    } else {

2238

        damage.push(*clip);

2239

2240

24

    ScrollShiftOutcome {

2241

24

        damage,

2242

24

        present_extra,

2243

24

2244

24

2245

2246

/// Clip-intersected bounds of every item painted AFTER scroll frame

2247

/// `scroll_id`'s `PopScrollFrame` that STRICTLY overlaps `clip_bounds`.

2248

///

2249

/// Anything composited over the frame inside its clip (the frame's own

2250

/// scrollbar, an open dropdown/context menu/tooltip, a sibling's box-shadow)

2251

/// gets DRAGGED by the `scroll_shift_region` memmove. Rather than making such

2252

/// frames ineligible for the fast path (a scrollbar would disable it for

2253

/// every scroll container), the caller adds these rects to the damage set so

2254

/// the dragged pixels are simply repainted after the shift.

2255

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

2256

#[must_use]

2257

26

pub fn overlay_rects_after_frame(

2258

26

    display_list: &DisplayList,

2259

26

    scroll_id: LocalScrollId,

2260

26

    clip_bounds: &LogicalRect,

2261

26

) -> Vec<LogicalRect> {

2262

26

    let mut out = Vec::new();

2263

99

    let Some(start) = display_list.items.iter().position(|it| {

2264

25

        matches!(it, DisplayListItem::PushScrollFrame { scroll_id: sid, .. } if *sid == scroll_id)

2265

99

    }) else {

2266

1

        return out;

2267

};

2268

25

    let end = find_matching_pop(&display_list.items, start, MatchKind::ScrollFrame)

2269

25

        .min(display_list.items.len());

2270

25

    let cx1 = clip_bounds.origin.x + clip_bounds.size.width;

2271

25

    let cy1 = clip_bounds.origin.y + clip_bounds.size.height;

2272

80

    for it in &display_list.items[end..] {

2273

80

        if it.is_state_management() {

2274

54

            continue;

2275

26

2276

26

        let Some(b) = it.bounds() else { continue };

2277

        // STRICT overlap: merely touching shares no pixels with the clip and

2278

        // cannot be dragged.

2279

26

        let ix = b.origin.x.max(clip_bounds.origin.x);

2280

26

        let iy = b.origin.y.max(clip_bounds.origin.y);

2281

26

        let ix1 = (b.origin.x + b.size.width).min(cx1);

2282

26

        let iy1 = (b.origin.y + b.size.height).min(cy1);

2283

26

        if ix1 > ix && iy1 > iy {

2284

11

            out.push(LogicalRect {

2285

11

                origin: LogicalPosition { x: ix, y: iy },

2286

11

                size: LogicalSize {

2287

11

                    width: ix1 - ix,

2288

11

                    height: iy1 - iy,

2289

11

},

2290

11

});

2291

25

2292

2293

25

out

2294

26

2295

2296

/// If `it` is a fully-opaque, square-cornered rectangle fill, its bounds.

2297

293

fn opaque_fill_rect(it: &DisplayListItem) -> Option<LogicalRect> {

2298

270

    match it {

2299

        DisplayListItem::Rect {

2300

270

            bounds,

2301

270

            color,

2302

270

            border_radius,

2303

270

        } if color.a == 255 && border_radius.is_zero() => Some(*bounds.inner()),

2304

29

        _ => None,

2305

2306

293

2307

2308

/// True if every ~4px sample of `target` lies inside some rect in `covers`.

2309

/// Point-sampled so sub-4px gaps (imperceptible if dragged) don't force a full

2310

/// repaint; empty `covers` → not covered.

2311

#[allow(clippy::suboptimal_flops)] // mul_add not guaranteed faster/available without target +fma;

2312

                                   // keep explicit a*b+c

2313

76

fn rect_covered_by(target: &LogicalRect, covers: &[LogicalRect]) -> bool {

2314

76

    if covers.is_empty() {

2315

6

        return false;

2316

70

2317

70

    let step = 4.0_f32;

2318

70

    let x0 = target.origin.x;

2319

70

    let y0 = target.origin.y;

2320

70

    let x1 = x0 + target.size.width;

2321

70

    let y1 = y0 + target.size.height;

2322

70

    let mut y = y0 + step * 0.5;

2323

    #[allow(clippy::while_float)]

2324

    // intentional bounded float loop (angle-wrap / pixel-step); an integer counter would be

2325

    // artificial

2326

1565

    while y < y1 {

2327

1503

        let mut x = x0 + step * 0.5;

2328

        #[allow(clippy::while_float)]

2329

        // intentional bounded float loop (angle-wrap / pixel-step); an integer counter would be

2330

        // artificial

2331

66790

        while x < x1 {

2332

135930

            let inside = covers.iter().any(|r| {

2333

135930

                x >= r.origin.x

2334

135930

                    && x < r.origin.x + r.size.width

2335

135929

                    && y >= r.origin.y

2336

135927

                    && y < r.origin.y + r.size.height

2337

135930

});

2338

65295

            if !inside {

2339

8

                return false;

2340

65287

2341

65287

            x += step;

2342

2343

1495

        y += step;

2344

2345

62

    true

2346

76

2347

2348

/// Apply CSS filters to a pixbuf at composite time.

2349

#[allow(clippy::suboptimal_flops)] // mul_add not guaranteed faster/available without target +fma; keep explicit a*b+c

2350

#[allow(

2351

    clippy::cast_possible_truncation,

2352

    clippy::cast_possible_wrap,

2353

    clippy::cast_sign_loss

2354

)] // bounded pixel/coord/colour/glyph cast

2355

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

2356

                                 // (one branch per case)

2357

22

fn apply_layer_filters(pixmap: &mut AzulPixmap, filters: &[StyleFilter], dpi_factor: f32) {

2358

44

    for filter in filters {

2359

22

        match filter {

2360

5

            StyleFilter::Blur(blur) => {

2361

5

                let rx = blur

2362

5

                    .width

2363

5

                    .to_pixels_internal(0.0, DEFAULT_FONT_SIZE, DEFAULT_FONT_SIZE)

2364

5

                    * dpi_factor;

2365

5

                let ry = blur

2366

5

                    .height

2367

5

                    .to_pixels_internal(0.0, DEFAULT_FONT_SIZE, DEFAULT_FONT_SIZE)

2368

5

                    * dpi_factor;

2369

5

                let radius = f32::midpoint(rx, ry).ceil() as u32;

2370

5

                if radius > 0 {

2371

1

                    let w = pixmap.width;

2372

1

                    let h = pixmap.height;

2373

1

                    let stride = (w * 4) as i32;

2374

1

                    let mut ra = unsafe {

2375

1

                        RowAccessor::new_with_buf(pixmap.data.as_mut_ptr(), w, h, stride)

2376

1

};

2377

1

                    stack_blur_rgba32(&mut ra, radius, radius);

2378

4

2379

2380

4

            StyleFilter::Opacity(pct) => {

2381

4

                let op = (pct.normalized() * 255.0).clamp(0.0, 255.0) as u32;

2382

16

                for chunk in pixmap.data.chunks_exact_mut(4) {

2383

16

                    chunk[3] = ((u32::from(chunk[3]) * op) / 255) as u8;

2384

16

2385

2386

4

            StyleFilter::Grayscale(pct) => {

2387

4

                let amount = pct.normalized().clamp(0.0, 1.0);

2388

16

                for chunk in pixmap.data.chunks_exact_mut(4) {

2389

16

                    let r = f32::from(chunk[0]);

2390

16

                    let g = f32::from(chunk[1]);

2391

16

                    let b = f32::from(chunk[2]);

2392

16

                    let gray = 0.2126 * r + 0.7152 * g + 0.0722 * b;

2393

16

                    chunk[0] = (r + (gray - r) * amount).clamp(0.0, 255.0) as u8;

2394

16

                    chunk[1] = (g + (gray - g) * amount).clamp(0.0, 255.0) as u8;

2395

16

                    chunk[2] = (b + (gray - b) * amount).clamp(0.0, 255.0) as u8;

2396

16

2397

2398

3

            StyleFilter::Brightness(pct) => {

2399

3

                let factor = pct.normalized().max(0.0);

2400

12

                for chunk in pixmap.data.chunks_exact_mut(4) {

2401

12

                    chunk[0] = (f32::from(chunk[0]) * factor).clamp(0.0, 255.0) as u8;

2402

12

                    chunk[1] = (f32::from(chunk[1]) * factor).clamp(0.0, 255.0) as u8;

2403

12

                    chunk[2] = (f32::from(chunk[2]) * factor).clamp(0.0, 255.0) as u8;

2404

12

2405

2406

            StyleFilter::Contrast(pct) => {

2407

                let factor = pct.normalized().max(0.0);

2408

                for chunk in pixmap.data.chunks_exact_mut(4) {

2409

                    chunk[0] = ((((f32::from(chunk[0]) / 255.0) - 0.5) * factor + 0.5) * 255.0)

2410

                        .clamp(0.0, 255.0) as u8;

2411

                    chunk[1] = ((((f32::from(chunk[1]) / 255.0) - 0.5) * factor + 0.5) * 255.0)

2412

                        .clamp(0.0, 255.0) as u8;

2413

                    chunk[2] = ((((f32::from(chunk[2]) / 255.0) - 0.5) * factor + 0.5) * 255.0)

2414

                        .clamp(0.0, 255.0) as u8;

2415

2416

2417

3

            StyleFilter::Invert(pct) => {

2418

3

                let amount = pct.normalized().clamp(0.0, 1.0);

2419

5008

                for chunk in pixmap.data.chunks_exact_mut(4) {

2420

5008

                    chunk[0] = (f32::from(chunk[0]) + (255.0 - 2.0 * f32::from(chunk[0])) * amount)

2421

5008

                        .clamp(0.0, 255.0) as u8;

2422

5008

                    chunk[1] = (f32::from(chunk[1]) + (255.0 - 2.0 * f32::from(chunk[1])) * amount)

2423

5008

                        .clamp(0.0, 255.0) as u8;

2424

5008

                    chunk[2] = (f32::from(chunk[2]) + (255.0 - 2.0 * f32::from(chunk[2])) * amount)

2425

5008

                        .clamp(0.0, 255.0) as u8;

2426

5008

2427

2428

            StyleFilter::Sepia(pct) => {

2429

                let amount = pct.normalized().clamp(0.0, 1.0);

2430

                for chunk in pixmap.data.chunks_exact_mut(4) {

2431

                    let r = f32::from(chunk[0]);

2432

                    let g = f32::from(chunk[1]);

2433

                    let b = f32::from(chunk[2]);

2434

                    let sr = (0.393 * r + 0.769 * g + 0.189 * b).min(255.0);

2435

                    let sg = (0.349 * r + 0.686 * g + 0.168 * b).min(255.0);

2436

                    let sb = (0.272 * r + 0.534 * g + 0.131 * b).min(255.0);

2437

                    chunk[0] = (r + (sr - r) * amount).clamp(0.0, 255.0) as u8;

2438

                    chunk[1] = (g + (sg - g) * amount).clamp(0.0, 255.0) as u8;

2439

                    chunk[2] = (b + (sb - b) * amount).clamp(0.0, 255.0) as u8;

2440

2441

2442

1

            StyleFilter::Saturate(pct) => {

2443

1

                let s = pct.normalized().max(0.0);

2444

4

                for chunk in pixmap.data.chunks_exact_mut(4) {

2445

4

                    let r = f32::from(chunk[0]);

2446

4

                    let g = f32::from(chunk[1]);

2447

4

                    let b = f32::from(chunk[2]);

2448

4

                    let gray = 0.2126 * r + 0.7152 * g + 0.0722 * b;

2449

4

                    chunk[0] = (gray + (r - gray) * s).clamp(0.0, 255.0) as u8;

2450

4

                    chunk[1] = (gray + (g - gray) * s).clamp(0.0, 255.0) as u8;

2451

4

                    chunk[2] = (gray + (b - gray) * s).clamp(0.0, 255.0) as u8;

2452

4

2453

2454

1

            StyleFilter::HueRotate(angle) => {

2455

1

                let rad = angle.to_degrees().to_radians();

2456

1

                let cos_a = rad.cos();

2457

1

                let sin_a = rad.sin();

2458

4

                for chunk in pixmap.data.chunks_exact_mut(4) {

2459

4

                    let r = f32::from(chunk[0]);

2460

4

                    let g = f32::from(chunk[1]);

2461

4

                    let b = f32::from(chunk[2]);

2462

4

                    let nr = (0.213 + 0.787 * cos_a - 0.213 * sin_a) * r

2463

4

                        + (0.715 - 0.715 * cos_a - 0.715 * sin_a) * g

2464

4

                        + (0.072 - 0.072 * cos_a + 0.928 * sin_a) * b;

2465

4

                    let ng = (0.213 - 0.213 * cos_a + 0.143 * sin_a) * r

2466

4

                        + (0.715 + 0.285 * cos_a + 0.140 * sin_a) * g

2467

4

                        + (0.072 - 0.072 * cos_a - 0.283 * sin_a) * b;

2468

4

                    let nb = (0.213 - 0.213 * cos_a - 0.787 * sin_a) * r

2469

4

                        + (0.715 - 0.715 * cos_a + 0.715 * sin_a) * g

2470

4

                        + (0.072 + 0.928 * cos_a + 0.072 * sin_a) * b;

2471

4

                    chunk[0] = nr.clamp(0.0, 255.0) as u8;

2472

4

                    chunk[1] = ng.clamp(0.0, 255.0) as u8;

2473

4

                    chunk[2] = nb.clamp(0.0, 255.0) as u8;

2474

4

2475

2476

1

            _ => {} /* Blend, Flood, ColorMatrix, DropShadow, ComponentTransfer, Offset,

2477

                     * Composite not yet implemented */

2478

2479

2480

22

2481

2482

/// Render a range of display list items into a layer pixbuf,

2483

/// offsetting coordinates by the layer's origin.

2484

300

fn render_display_list_range(

2485

300

    display_list: &DisplayList,

2486

300

    pixmap: &mut AzulPixmap,

2487

300

    start: usize,

2488

300

    end: usize,

2489

300

    // Index ranges (start..end) that belong to CHILD layers (nested scroll

2490

300

    // frames / opacity / transform groups). Those items render into the child's

2491

300

    // OWN pixbuf, so they must be skipped here — otherwise they're drawn twice

2492

300

    // (once in this layer at absolute coords AND once in the child layer),

2493

300

    // which produced overlapping / ghosted text in overflow:scroll content.

2494

300

    skip_ranges: &[(usize, usize)],

2495

300

    offset_x: f32,

2496

300

    offset_y: f32,

2497

300

    dpi_factor: f32,

2498

300

    renderer_resources: &RendererResources,

2499

300

    font_manager: &FontManager<FontRef>,

2500

300

    glyph_cache: &mut GlyphCache,

2501

300

    render_state: &CpuRenderState,

2502

300

) -> Result<(), String> {

2503

300

    let mut transform_stack = vec![TransAffine::new()];

2504

300

    let mut clip_stack: Vec<Option<AzRect>> = vec![None];

2505

300

    let mut real_clip_stack: Vec<Option<AzRect>> = vec![None];

2506

300

    let mut mask_stack: Vec<MaskEntry> = Vec::new();

2507

    // Apply the layer origin offset: content is translated by -(offset_x,offset_y)

2508

    // so it's rendered RELATIVE to this layer's pixbuf origin (which is then

2509

    // composited back at +layer_origin). The renderer translates positions by

2510

    // `pos - scroll_offset`, so seeding the scroll-offset stack with the layer

2511

    // origin achieves the relative placement. Previously offset_x/offset_y were

2512

    // ignored, so child layers were double-offset (content drawn at absolute

2513

    // coords then composited at +origin) — text fell to the bottom of the box.

2514

300

    let mut scroll_offset_stack: Vec<(f32, f32)> = vec![(offset_x, offset_y)];

2515

300

    let mut text_shadow_stack: Vec<azul_css::props::style::box_shadow::StyleBoxShadow> = Vec::new();

2516

2517

3291

    for i in start..end {

2518

        // Skip items rendered by a child layer (see skip_ranges doc above).

2519

3291

        if skip_ranges.iter().any(|(s, e)| i >= *s && i < *e) {

2520

535

            continue;

2521

2756

2522

2756

        let item = &display_list.items[i];

2523

2756

        render_single_item(

2524

2756

            item,

2525

2756

            display_list.uniform_text_bgs.get(i).copied().flatten(),

2526

2756

            pixmap,

2527

2756

            dpi_factor,

2528

2756

            renderer_resources,

2529

2756

            font_manager,

2530

2756

            glyph_cache,

2531

2756

            &mut transform_stack,

2532

2756

            &mut clip_stack,

2533

2756

            &mut real_clip_stack,

2534

2756

            &mut mask_stack,

2535

2756

            &mut scroll_offset_stack,

2536

2756

            &mut text_shadow_stack,

2537

2756

            render_state,

2538

)?;

2539

2540

2541

300

    Ok(())

2542

300

2543

2544

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

2545

// AzulPixmap — replacement for tiny_skia::Pixmap

2546

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

2547

2548

/// Compute damage rects by comparing two display lists item by item.

2549

///

2550

/// Returns a list of bounding rects that need repainting, or `None` if a

2551

/// full repaint is required (structural change, different item count, etc.).

2552

///

2553

/// The comparison is conservative: any item whose bounds or content changed

2554

/// produces a damage rect covering both the old and new bounds.

2555

///

2556

/// The returned rects are in VIEWPORT space. Items inside a scroll frame are

2557

/// stored at CONTENT coords but render at `pos - scroll_offset`, so a changed

2558

/// item's bounds are projected through the accumulated scroll offset of its

2559

/// enclosing frame(s) — the OLD item through `old_offsets` (where its pixels

2560

/// were on screen), the NEW item through `new_offsets` (where they will be).

2561

/// Without this projection, damage for items inside a scrolled frame lands at

2562

/// the content-space position (off by exactly the scroll offset), so the

2563

/// consumer repaints the wrong band and the changed item stays visually stale.

2564

/// Runtime toggle for the DAMAGE REFINEMENTS (skip non-painting items,

2565

/// symmetric-difference strips for same-origin solid rects / clips).

2566

/// Default ON. They were landed default-OFF because honest (smaller)

2567

/// damage un-masked what looked like a cross-path LCD divergence; the

2568

/// real defect was twofold and is FIXED: (1) the FIR spread in the LCD

2569

/// pixfmts wrote 2 stripes outside the renderer clip, double-blending

2570

/// retained fringe on damage-rect repaints (agg-rust `set_stripe_clip`),

2571

/// and (2) a changed Text item's damage did not cover the 1-device-px

2572

/// fringe overhang (inflated in the diff below). The corpus damage-

2573

/// soundness gate is green with the refinements on; `AZ_DL_DIFF_REFINE=0`

2574

/// remains as the kill-switch.

2575

static DL_DIFF_REFINEMENTS: core::sync::atomic::AtomicU8 = core::sync::atomic::AtomicU8::new(0);

2576

2577

#[must_use]

2578

2992

pub fn dl_diff_refinements_enabled() -> bool {

2579

    use core::sync::atomic::Ordering;

2580

2992

    match DL_DIFF_REFINEMENTS.load(Ordering::Relaxed) {

2581

2970

        1 => true,

2582

        2 => false,

2583

        _ => {

2584

            // Default ON; the env var forces either way ("0"/"off" = off).

2585

22

            let on = match std::env::var("AZ_DL_DIFF_REFINE") {

2586

                Ok(v) => !(v == "0" || v.eq_ignore_ascii_case("off")),

2587

22

                Err(_) => true,

2588

};

2589

22

            DL_DIFF_REFINEMENTS.store(if on { 1 } else { 2 }, Ordering::Relaxed);

2590

22

on

2591

2592

2593

2992

2594

2595

/// Force the refinements on/off (tests; overrides the env).

2596

pub fn set_dl_diff_refinements(on: bool) {

2597

    use core::sync::atomic::Ordering;

2598

    DL_DIFF_REFINEMENTS.store(if on { 1 } else { 2 }, Ordering::Relaxed);

2599

2600

2601

/// Round-3 translate hint: a mismatching item pair whose OLD geometry

2602

/// translated by `delta` equals the NEW one, and whose old bounds sit

2603

/// inside `region_old`, is a MOVE — collected into the returned moved

2604

/// union instead of damage. The caller blits that union by `delta` and

2605

/// repaints only the rest. See `items_equal_translated`.

2606

#[derive(Debug, Clone, Copy)]

2607

pub struct TranslateHint {

2608

    pub delta: (f32, f32),

2609

    pub region_old: LogicalRect,

2610

2611

2612

/// Decide whether a layout patch's move may be presented as a BLIT.

2613

///

2614

/// Extracted so the real backend and the e2e harness make the same decision

2615

/// from the same inputs. They did not: `dll/.../headless/mod.rs` had this logic

2616

/// inline and `layout/src/e2e/cpu_backend.rs` had none of it — zero mentions of

2617

/// `TranslateHint`, `dominant_delta` or the already-shifted guard. The harness

2618

/// therefore could not execute the blit path AT ALL, which is where the

2619

/// "typing does not repaint" bug lives: a stale hint blits the previous frame

2620

/// by `dominant_delta`, so the damage rect is right and the pixels under it are

2621

/// the old ones, translated.

2622

///

2623

/// The conditions, all of which must hold:

2624

/// - the dominant delta is INTEGRAL in physical pixels; a fractional blit would change every

2625

///   subpixel phase, so those frames must re-render

2626

/// - it actually moved at least one physical pixel

2627

/// - the previous frame's pixels are trustworthy (`can_reuse_previous_frame`)

2628

/// - this display list has not already been shifted, which is what `already_shifted` carries (a

2629

///   buffers-held retry would shift twice)

2630

#[must_use]

2631

16771

pub fn translate_hint_for_patch(

2632

16771

    last_patch_move: Option<&crate::solver3::display_list::PatchMoveSummary>,

2633

16771

    dpi_factor: f32,

2634

16771

    can_reuse_previous_frame: bool,

2635

16771

    already_shifted: bool,

2636

16771

    any_scroll_nonzero: bool,

2637

16771

) -> Option<(TranslateHint, Vec<LogicalRect>)> {

2638

    // The mover rects/regions come from `compute_patch_move_summary` in

2639

    // CONTENT space - no scroll projection exists on that producer. At zero

2640

    // scroll the spaces coincide; with any active offset a blit would memmove

2641

    // the wrong pixels (garbled bands during a scrolled resize). Until the

2642

    // producer projects through the scroll chain, a scrolled window falls

2643

    // back to plain damage.

2644

16771

    if any_scroll_nonzero {

2645

16429

        return None;

2646

342

2647

342

    let m = last_patch_move?;

2648

6

    let px = m.dominant_delta.x * dpi_factor;

2649

6

    let py = m.dominant_delta.y * dpi_factor;

2650

6

    let integral = (px - px.round()).abs() < 0.001 && (py - py.round()).abs() < 0.001;

2651

6

    let moved_any = px.round().abs() >= 1.0 || py.round().abs() >= 1.0;

2652

6

    if integral && moved_any && can_reuse_previous_frame && !already_shifted {

2653

2

        Some((

2654

2

            TranslateHint {

2655

2

                delta: (m.dominant_delta.x, m.dominant_delta.y),

2656

2

                region_old: m.moved_region_old,

2657

2

},

2658

2

            m.exceptions.clone(),

2659

2

))

2660

    } else {

2661

4

        None

2662

2663

16771

2664

2665

/// What [`execute_translate_blit`] produced: paint damage to merge, and

2666

/// present-only regions (whole mover clips — every pixel in them changed on

2667

/// screen even though only strips were rasterised).

2668

#[derive(Debug, Default)]

2669

pub struct TranslateBlitResult {

2670

    pub damage: Vec<LogicalRect>,

2671

    pub present_extra: Vec<LogicalRect>,

2672

2673

2674

/// ROUND 3 of the incremental present — the layout-translation blit. The

2675

/// translated diff classified the dominant movers as MOVES (no damage);

2676

/// shift their pixels here and repaint only the exceptions + exposed strips.

2677

/// Sign map: the shifter takes SCROLL deltas (offset +d moves content by

2678

/// −d), so a layout move BY +d passes delta −d anchored at offset (0,0).

2679

///

2680

/// Extracted from the dll headless present so BOTH backends (the shells'

2681

/// `render_frame` and the e2e twin) execute the identical blit — before

2682

/// this, the twin had no notion of a `TranslateHint` at all, so every

2683

/// mover-blit bug was structurally untestable in the harness.

2684

///

2685

/// One blit PER MOVER RECT (never the union — the gaps between movers are

2686

/// static backdrop that must not be dragged). Clip per mover =

2687

/// old∪(old+delta) so both the vacated source and the destination lie

2688

/// inside the memmove region; exposed strips repaint per mover.

2689

#[must_use]

2690

pub fn execute_translate_blit(

2691

    output: &mut AzulPixmap,

2692

    hint: &TranslateHint,

2693

    exceptions: &[LogicalRect],

2694

    mover_rects: &[LogicalRect],

2695

    new_display_list: &DisplayList,

2696

    dpi_factor: f32,

2697

    pool_order: bool,

2698

) -> TranslateBlitResult {

2699

    let mut res = TranslateBlitResult::default();

2700

    let d = hint.delta;

2701

    if std::env::var_os("AZ_BLIT_DEBUG").is_some() {

2702

        eprintln!(

2703

            "[blit] delta={:?} movers={} exceptions={}",

2704

d,

2705

            mover_rects.len(),

2706

            exceptions.len()

2707

);

2708

        for m in mover_rects {

2709

            eprintln!("[blit]   mover {m:?}");

2710

2711

        for e in exceptions {

2712

            eprintln!("[blit]   exception {e:?}");

2713

2714

2715

    for mr in mover_rects {

2716

        let dest = LogicalRect {

2717

            origin: LogicalPosition {

2718

                x: mr.origin.x + d.0,

2719

                y: mr.origin.y + d.1,

2720

},

2721

            size: mr.size,

2722

};

2723

        let x0 = mr.origin.x.min(dest.origin.x);

2724

        let y0 = mr.origin.y.min(dest.origin.y);

2725

        let x1 = (mr.origin.x + mr.size.width).max(dest.origin.x + dest.size.width);

2726

        let y1 = (mr.origin.y + mr.size.height).max(dest.origin.y + dest.size.height);

2727

        let clip = LogicalRect {

2728

            origin: LogicalPosition { x: x0, y: y0 },

2729

            size: LogicalSize {

2730

                width: x1 - x0,

2731

                height: y1 - y0,

2732

},

2733

};

2734

        let shift_exact = if pool_order {

2735

            scroll_shift_region_exact_pool_order

2736

        } else {

2737

            scroll_shift_region_exact

2738

};

2739

        let strips = shift_exact(output, &clip, (-d.0, -d.1), (0.0, 0.0), dpi_factor);

2740

        // Inflate the vacated strips by 1px: LCD fringe of a run hugging the

2741

        // mover's edge hangs one device pixel OUTSIDE the mover rect, so the

2742

        // un-inflated vacated region leaves that column stale after the move

2743

        // (the full-repaint control clears it via the diff's own text

2744

        // inflation — the gate diverged by exactly that column). A wider

2745

        // strip that now cuts a destination run is already handled by the

2746

        // fringe-touching-runs-damaged-whole rule below.

2747

        let strips: Vec<LogicalRect> = strips

2748

            .iter()

2749

            .map(|r| LogicalRect {

2750

                origin: LogicalPosition {

2751

                    x: r.origin.x - 1.0,

2752

                    y: r.origin.y - 1.0,

2753

},

2754

                size: LogicalSize {

2755

                    width: r.size.width + 2.0,

2756

                    height: r.size.height + 2.0,

2757

},

2758

})

2759

            .collect();

2760

        res.damage.extend(strips.iter().copied());

2761

        // LCD text is FIR-fringed: a run STARTING at the blit destination

2762

        // hangs 1px of fringe INTO the vacated strip. A strip-clipped repaint

2763

        // cannot reproduce that fringe (the colorimetric blend reads

2764

        // neighbours), so any text run whose 1px-inflated bounds touch a

2765

        // strip is damaged WHOLE — cleared and re-rendered exactly like the

2766

        // full-repaint control.

2767

        for strip in &strips {

2768

            for item in &new_display_list.items {

2769

                if let DisplayListItem::Text { .. } = item {

2770

                    if let Some(b) = item.bounds() {

2771

                        let inflated = LogicalRect {

2772

                            origin: LogicalPosition {

2773

                                x: b.origin.x - 1.0,

2774

                                y: b.origin.y - 1.0,

2775

},

2776

                            size: LogicalSize {

2777

                                width: b.size.width + 2.0,

2778

                                height: b.size.height + 2.0,

2779

},

2780

};

2781

                        let ix = inflated.origin.x < strip.origin.x + strip.size.width

2782

                            && strip.origin.x < inflated.origin.x + inflated.size.width

2783

                            && inflated.origin.y < strip.origin.y + strip.size.height

2784

                            && strip.origin.y < inflated.origin.y + inflated.size.height;

2785

                        if ix {

2786

                            res.damage.push(inflated);

2787

2788

2789

2790

2791

2792

        res.present_extra.push(clip);

2793

2794

    res.damage.extend(exceptions.iter().copied());

2795

res

2796

2797

2798

/// [`compute_display_list_damage`] + the translate hint. Returns

2799

/// `(damage, moved_union)`; `moved_union` is `None` when nothing matched

2800

/// the hint (caller falls back to plain damage).

2801

/// Damage for a STRUCTURALLY changed display list (item count or item kinds

2802

/// differ): the visually-equal PREFIX and SUFFIX are unchanged, so everything

2803

/// that changed lies in the middle window — damage is the union of the OLD

2804

/// and NEW middle windows' bounds, mapped to visual space through the scroll

2805

/// stack. Sound for any localized insertion / removal / replacement; a change

2806

/// that touches everything degrades to a full-window rect, which is what the

2807

/// bail produced anyway.

2808

///

2809

/// `None` (keep the full repaint) when any scroll offset changed between the

2810

/// frames — a scrolled frame moves items the equality scan would misjudge.

2811

136

fn windowed_structural_damage(

2812

136

    old: &DisplayList,

2813

136

    new: &DisplayList,

2814

136

    old_offsets: &ScrollOffsetMap,

2815

136

    new_offsets: &ScrollOffsetMap,

2816

136

) -> Option<Vec<LogicalRect>> {

2817

136

    if old_offsets != new_offsets {

2818

3

        return None;

2819

133

2820

2821

133

    let o = &old.items;

2822

133

    let n = &new.items;

2823

133

    let min_len = o.len().min(n.len());

2824

2825

133

    let mut prefix = 0;

2826

1060

    while prefix < min_len && o[prefix].is_visually_equal(&n[prefix]) {

2827

927

        prefix += 1;

2828

927

2829

133

    let mut suffix = 0;

2830

390

    while suffix < min_len - prefix

2831

353

        && o[o.len() - 1 - suffix].is_visually_equal(&n[n.len() - 1 - suffix])

2832

257

2833

257

        suffix += 1;

2834

257

2835

2836

    // The accumulated scroll offset at the prefix boundary (offsets are equal

2837

    // between the frames, so one walk over the new list serves both).

2838

133

    let mut stack: Vec<(f32, f32)> = vec![(0.0, 0.0)];

2839

929

    for item in &n[..prefix] {

2840

927

        match item {

2841

54

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

2842

54

                let (ax, ay) = *stack.last().unwrap_or(&(0.0, 0.0));

2843

54

                let (sx, sy) = new_offsets.get(scroll_id).copied().unwrap_or((0.0, 0.0));

2844

54

                stack.push((ax + sx, ay + sy));

2845

54

2846

            DisplayListItem::PopScrollFrame => {

2847

20

                if stack.len() > 1 {

2848

20

                    stack.pop();

2849

20

2850

2851

853

            _ => {}

2852

2853

2854

2855

    // A text-shadow's extent is not representable per item (the shadow

2856

    // paints around every glyph run until the Pop) — if EITHER changed

2857

    // window contains one, bail to the full-repaint path rather than

2858

    // under-damage the fringe. This must abort the WHOLE fallback: bailing

2859

    // from just one window's union would return the other window's rect as

2860

    // if it were complete coverage.

2861

133

    let shadow_in_window = o[prefix..o.len() - suffix]

2862

133

        .iter()

2863

133

        .chain(n[prefix..n.len() - suffix].iter())

2864

1116

        .any(|i| matches!(i, DisplayListItem::PushTextShadow { .. }));

2865

133

    if shadow_in_window {

2866

        return None;

2867

133

2868

2869

    // PER-ITEM rects for the middle window of one list, tracking Push/Pop

2870

    // inside it. This used to union the whole window into ONE rect per side —

2871

    // sound, but as coarse as the window: an Enter in a TextArea unioned the

2872

    // full-width HitTestArea in with the ~60px-wide moved lines and damaged

2873

    // 375×48 where ~60×48 changed. Per-item rects (coalesced below) cover the

2874

    // same changed pixels exactly: every pixel a window item painted, before

2875

    // or after, lies in its own item's rect, and every pixel BETWEEN window

2876

    // items belongs to visually-equal prefix/suffix items, which by

2877

    // definition did not change.

2878

133

    let refine = dl_diff_refinements_enabled();

2879

133

    let mut damage: Vec<LogicalRect> = Vec::new();

2880

133

    let mut skipped_nonpainting = false;

2881

266

    let mut collect_window = |items: &[DisplayListItem], offsets: &ScrollOffsetMap| {

2882

266

        let mut stack = stack.clone();

2883

1382

        for item in items {

2884

1116

            match item {

2885

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

2886

                    let (ax, ay) = *stack.last().unwrap_or(&(0.0, 0.0));

2887

                    let (sx, sy) = offsets.get(scroll_id).copied().unwrap_or((0.0, 0.0));

2888

                    stack.push((ax + sx, ay + sy));

2889

2890

                DisplayListItem::PopScrollFrame => {

2891

1

                    if stack.len() > 1 {

2892

                        stack.pop();

2893

1

2894

2895

1115

                _ => {}

2896

2897

            // Items that never RASTERIZE never produce paint damage — the

2898

            // same rule as the paired path's refinement: hit testing and

2899

            // PDF/a11y metadata read the NEW display list, no pixels are

2900

            // involved. In the union days their (viewport-sized) rects were

2901

            // absorbed anyway; per-item they WOULD dominate the result.

2902

1116

            if refine

2903

667

                && matches!(

2904

1116

                    item,

2905

                    DisplayListItem::HitTestArea { .. } | DisplayListItem::TextLayout { .. }

2906

2907

2908

449

                skipped_nonpainting = true;

2909

449

                continue;

2910

667

2911

            // INK bounds, not box bounds: a box-shadow's blur/spread and a

2912

            // glyph run's overhang paint OUTSIDE `bounds()`. Unioning the

2913

            // un-expanded rects left the moved shadow's fringe stale — the

2914

            // Switch toggle's 2830 stale px — and, for Text, the LCD

2915

            // subpixel fringe one column outside the box.

2916

667

            let Some(b) = item.visual_bounds().or_else(|| item.bounds()) else {

2917

33

                continue;

2918

};

2919

634

            let (ox, oy) = *stack.last().unwrap_or(&(0.0, 0.0));

2920

634

            let mut visual = LogicalRect {

2921

634

                origin: LogicalPosition {

2922

634

                    x: b.origin.x - ox,

2923

634

                    y: b.origin.y - oy,

2924

634

},

2925

634

                size: b.size,

2926

634

};

2927

            // Mirror the paired path's rule: LCD subpixel AA (the shipping

2928

            // default) bleeds 1 logical px past the glyph ink.

2929

634

            if matches!(item, DisplayListItem::Text { .. }) {

2930

365

                visual.origin.x -= 1.0;

2931

365

                visual.origin.y -= 1.0;

2932

365

                visual.size.width += 2.0;

2933

365

                visual.size.height += 2.0;

2934

449

2935

634

            damage.push(visual);

2936

2937

266

};

2938

2939

133

    collect_window(&o[prefix..o.len() - suffix], old_offsets);

2940

133

    collect_window(&n[prefix..n.len() - suffix], new_offsets);

2941

2942

133

    if damage.is_empty() {

2943

        // Every window item was a non-painting one (hit areas, metadata):

2944

        // nothing rasterizes differently, so there is genuinely no paint

2945

        // damage — the same `Some(empty)` the paired path produces for a

2946

        // HitTestArea-only change.

2947

1

        if skipped_nonpainting {

2948

            return Some(damage);

2949

1

2950

        // A window of only Push/Pop pairs (no bounds-carrying item) still

2951

        // changed structure somewhere — be conservative rather than claim

2952

        // "no damage".

2953

1

        return None;

2954

132

2955

132

    coalesce_damage_rects(&mut damage);

2956

132

    Some(damage)

2957

136

2958

2959

#[must_use]

2960

124

pub fn compute_display_list_damage_translated(

2961

124

    old: &DisplayList,

2962

124

    new: &DisplayList,

2963

124

    old_offsets: &ScrollOffsetMap,

2964

124

    new_offsets: &ScrollOffsetMap,

2965

124

    hint: Option<&TranslateHint>,

2966

124

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

2967

124

    compute_display_list_damage_impl(old, new, old_offsets, new_offsets, hint)

2968

124

2969

2970

#[must_use]

2971

967

pub fn compute_display_list_damage(

2972

967

    old: &DisplayList,

2973

967

    new: &DisplayList,

2974

967

    old_offsets: &ScrollOffsetMap,

2975

967

    new_offsets: &ScrollOffsetMap,

2976

967

) -> Option<Vec<LogicalRect>> {

2977

967

    compute_display_list_damage_impl(old, new, old_offsets, new_offsets, None)

2978

967

        .map(|(damage, _moved)| damage)

2979

967

2980

2981

#[allow(clippy::too_many_lines)]

2982

1091

fn compute_display_list_damage_impl(

2983

1091

    old: &DisplayList,

2984

1091

    new: &DisplayList,

2985

1091

    old_offsets: &ScrollOffsetMap,

2986

1091

    new_offsets: &ScrollOffsetMap,

2987

1091

    hint: Option<&TranslateHint>,

2988

1091

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

2989

    // Different item counts: a LOCALIZED structural change (a paragraph that

2990

    // now wraps to one more line emits one more Text item, an inserted node,

2991

    // a removed one). This used to bail to a full-window repaint — which is

2992

    // how retyping a paragraph's text repainted the whole window whenever

2993

    // the new text changed the LINE COUNT (font-metrics dependent: DejaVu

2994

    // wraps where Helvetica does not, so the same scenario was green on

2995

    // macOS and red on ubuntu). The windowed fallback below damages the

2996

    // changed middle instead.

2997

1091

    if old.items.len() != new.items.len() {

2998

133

        return windowed_structural_damage(old, new, old_offsets, new_offsets)

2999

133

            .map(|damage| (damage, None));

3000

958

3001

3002

958

    let mut damage = Vec::new();

3003

958

    let mut moved_union: Option<LogicalRect> = None;

3004

3005

    // Accumulated (old, new) scroll offsets of the enclosing frames. The two

3006

    // lists are structurally identical (discriminants checked below), so one

3007

    // stack driven by the new list tracks both.

3008

958

    let mut offset_stack: Vec<((f32, f32), (f32, f32))> = vec![((0.0, 0.0), (0.0, 0.0))];

3009

3010

612369

    for (old_item, new_item) in old.items.iter().zip(new.items.iter()) {

3011

        // Compare discriminant first (cheap)

3012

612369

        if std::mem::discriminant(old_item) != std::mem::discriminant(new_item) {

3013

            // Structural change with equal counts — same windowed fallback as

3014

            // the count-mismatch case above.

3015

3

            return windowed_structural_damage(old, new, old_offsets, new_offsets)

3016

3

                .map(|damage| (damage, None));

3017

612366

3018

3019

612366

        match new_item {

3020

81

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

3021

81

                let (acc_old, acc_new) = *offset_stack.last().unwrap_or(&((0.0, 0.0), (0.0, 0.0)));

3022

81

                let o = old_offsets.get(scroll_id).copied().unwrap_or((0.0, 0.0));

3023

81

                let n = new_offsets.get(scroll_id).copied().unwrap_or((0.0, 0.0));

3024

81

                offset_stack.push((

3025

81

                    (acc_old.0 + o.0, acc_old.1 + o.1),

3026

81

                    (acc_new.0 + n.0, acc_new.1 + n.1),

3027

81

));

3028

81

3029

            DisplayListItem::PopScrollFrame => {

3030

81

                if offset_stack.len() > 1 {

3031

81

                    offset_stack.pop();

3032

81

3033

3034

612204

            _ => {}

3035

3036

3037

        // Compare full visual content, not just bounds — a color or text

3038

        // change within the same bounds must still produce a damage rect.

3039

        // Use visual_bounds() to include effects like box-shadow extent.

3040

612366

        if !old_item.is_visually_equal(new_item) {

3041

2859

            let refine = dl_diff_refinements_enabled();

3042

            // Items that never RASTERIZE must never produce PAINT damage.

3043

            // The root's HitTestArea resizes with the window (640→680 =

3044

            // a full-viewport "change") and TextLayout is PDF/a11y

3045

            // metadata — both were forcing 100% repaints on every resize.

3046

            // Hit testing and metadata consumers read the NEW display list

3047

            // directly; no pixels are involved.

3048

2859

            if refine

3049

2859

                && matches!(

3050

2859

                    new_item,

3051

                    DisplayListItem::HitTestArea { .. } | DisplayListItem::TextLayout { .. }

3052

3053

3054

                continue;

3055

2859

3056

            // A Border whose widths are all None/absent paints NOTHING —

3057

            // the generator emits one per node regardless, and a resize of

3058

            // a borderless node's Border item was damaging its whole rect

3059

            // (the viewport, for the root).

3060

            if let (

3061

                DisplayListItem::Border { widths: ow, .. },

3062

                DisplayListItem::Border { widths: nw, .. },

3063

2859

            ) = (old_item, new_item)

3064

3065

                if refine {

3066

                    // Sides have distinct wrapper types; small duplication

3067

                    // (same inner PixelValue) beats a generic bound here.

3068

                    let paints = |w: &crate::solver3::display_list::StyleBorderWidths| {

3069

                        w.top.as_ref().map_or(0.0, |v| {

3070

                            v.get_property()

3071

                                .map_or(0.0, |x| x.inner.to_pixels_internal(0.0, 16.0, 16.0))

3072

                        }) > 0.0

3073

                            || w.right.as_ref().map_or(0.0, |v| {

3074

                                v.get_property()

3075

                                    .map_or(0.0, |x| x.inner.to_pixels_internal(0.0, 16.0, 16.0))

3076

                            }) > 0.0

3077

                            || w.bottom.as_ref().map_or(0.0, |v| {

3078

                                v.get_property()

3079

                                    .map_or(0.0, |x| x.inner.to_pixels_internal(0.0, 16.0, 16.0))

3080

                            }) > 0.0

3081

                            || w.left.as_ref().map_or(0.0, |v| {

3082

                                v.get_property()

3083

                                    .map_or(0.0, |x| x.inner.to_pixels_internal(0.0, 16.0, 16.0))

3084

                            }) > 0.0

3085

};

3086

                    if !paints(ow) && !paints(nw) {

3087

                        continue;

3088

3089

                } else {

3090

                    // fall through to plain damage below

3091

3092

2859

3093

            // PushStackingContext carries region metadata (bounds + z);

3094

            // its geometry change does not itself paint — children carry

3095

            // their own damage. (Same class as HitTestArea.)

3096

2859

            if refine && matches!(new_item, DisplayListItem::PushStackingContext { .. }) {

3097

6

                continue;

3098

2853

3099

2853

            let (acc_old, acc_new) = *offset_stack.last().unwrap_or(&((0.0, 0.0), (0.0, 0.0)));

3100

            // A SOLID rect that only changed SIZE (same origin, color,

3101

            // radius) — the width:100% root background on every resize —

3102

            // damages only its SYMMETRIC DIFFERENCE: pixels inside both old

3103

            // and new are identical (uniform fill), so old∪new (the whole

3104

            // viewport, forcing a full repaint per resize) over-damages by

3105

            // exactly the intersection. Emit the exposed right/bottom (or

3106

            // shrunk) strips instead.

3107

            // Same-origin size-only change of a CLIP: the intersection kept

3108

            // its clipping; only the delta strips can newly show or hide

3109

            // content. (A moved clip falls through to full old∪new.)

3110

            if let (

3111

                DisplayListItem::PushClip {

3112

                    bounds: ob,

3113

                    border_radius: obr,

3114

},

3115

                DisplayListItem::PushClip {

3116

                    bounds: nb,

3117

                    border_radius: nbr,

3118

},

3119

2853

            ) = (old_item, new_item)

3120

3121

                if refine {

3122

                    let same_origin = (ob.0.origin.x - nb.0.origin.x).abs() < 0.01

3123

                        && (ob.0.origin.y - nb.0.origin.y).abs() < 0.01;

3124

                    if same_origin && obr == nbr {

3125

                        let o = ob.0;

3126

                        let nr = nb.0;

3127

                        let (wx0, wx1) = (

3128

                            o.size.width.min(nr.size.width),

3129

                            o.size.width.max(nr.size.width),

3130

);

3131

                        if wx1 - wx0 > 0.01 {

3132

                            damage.push(LogicalRect {

3133

                                origin: LogicalPosition {

3134

                                    x: nr.origin.x + wx0,

3135

                                    y: nr.origin.y,

3136

},

3137

                                size: LogicalSize {

3138

                                    width: wx1 - wx0,

3139

                                    height: o.size.height.max(nr.size.height),

3140

},

3141

});

3142

3143

                        let (hy0, hy1) = (

3144

                            o.size.height.min(nr.size.height),

3145

                            o.size.height.max(nr.size.height),

3146

);

3147

                        if hy1 - hy0 > 0.01 {

3148

                            damage.push(LogicalRect {

3149

                                origin: LogicalPosition {

3150

                                    x: nr.origin.x,

3151

                                    y: nr.origin.y + hy0,

3152

},

3153

                                size: LogicalSize {

3154

                                    width: o.size.width.max(nr.size.width),

3155

                                    height: hy1 - hy0,

3156

},

3157

});

3158

3159

                        continue;

3160

3161

                } else {

3162

                    // plain damage below

3163

3164

2853

3165

            if let (

3166

                DisplayListItem::Rect {

3167

30

                    bounds: ob,

3168

30

                    color: oc,

3169

30

                    border_radius: obr,

3170

},

3171

                DisplayListItem::Rect {

3172

30

                    bounds: nb,

3173

30

                    color: nc,

3174

30

                    border_radius: nbr,

3175

},

3176

2853

            ) = (old_item, new_item)

3177

3178

30

                if refine {

3179

30

                    let same_origin = (ob.0.origin.x - nb.0.origin.x).abs() < 0.01

3180

20

                        && (ob.0.origin.y - nb.0.origin.y).abs() < 0.01;

3181

30

                    if same_origin && oc == nc && obr == nbr && obr.is_zero() {

3182

9

                        let (acc_o, acc_n) = (acc_old, acc_new);

3183

9

                        let scrolled =

3184

                            |r: &crate::solver3::display_list::WindowLogicalRect,

3185

                             acc: (f32, f32)| LogicalRect {

3186

18

                                origin: LogicalPosition {

3187

18

                                    x: r.0.origin.x - acc.0,

3188

18

                                    y: r.0.origin.y - acc.1,

3189

18

},

3190

18

                                size: r.0.size,

3191

18

};

3192

9

                        let o = scrolled(ob, acc_o);

3193

9

                        let nr = scrolled(nb, acc_n);

3194

                        // Horizontal strip (width delta), full height of the taller.

3195

9

                        let (wx0, wx1) = (

3196

9

                            o.size.width.min(nr.size.width),

3197

9

                            o.size.width.max(nr.size.width),

3198

9

);

3199

9

                        if wx1 - wx0 > 0.01 {

3200

9

                            damage.push(LogicalRect {

3201

9

                                origin: LogicalPosition {

3202

9

                                    x: nr.origin.x + wx0,

3203

9

                                    y: nr.origin.y,

3204

9

},

3205

9

                                size: LogicalSize {

3206

9

                                    width: wx1 - wx0,

3207

9

                                    height: o.size.height.max(nr.size.height),

3208

9

},

3209

9

});

3210

9

3211

                        // Vertical strip (height delta), full width of the wider.

3212

9

                        let (hy0, hy1) = (

3213

9

                            o.size.height.min(nr.size.height),

3214

9

                            o.size.height.max(nr.size.height),

3215

9

);

3216

9

                        if hy1 - hy0 > 0.01 {

3217

2

                            damage.push(LogicalRect {

3218

2

                                origin: LogicalPosition {

3219

2

                                    x: nr.origin.x,

3220

2

                                    y: nr.origin.y + hy0,

3221

2

},

3222

2

                                size: LogicalSize {

3223

2

                                    width: o.size.width.max(nr.size.width),

3224

2

                                    height: hy1 - hy0,

3225

2

},

3226

2

});

3227

7

3228

9

                        continue;

3229

21

3230

                } else {

3231

                    // plain damage below

3232

3233

2823

3234

            // Round-3: a pure translation by the hint's delta, inside its

3235

            // region, is a MOVE — the caller blits it; no damage here.

3236

2844

            if let Some(h) = hint {

3237

                if let Some(ob) = old_item.visual_bounds() {

3238

                    let inside = ob.origin.x >= h.region_old.origin.x - 0.5

3239

                        && ob.origin.y >= h.region_old.origin.y - 0.5

3240

                        && ob.origin.x + ob.size.width

3241

                            <= h.region_old.origin.x + h.region_old.size.width + 0.5

3242

                        && ob.origin.y + ob.size.height

3243

                            <= h.region_old.origin.y + h.region_old.size.height + 0.5;

3244

                    if inside && items_equal_translated(old_item, new_item, h.delta) {

3245

                        let vr = LogicalRect {

3246

                            origin: LogicalPosition {

3247

                                x: ob.origin.x - acc_old.0,

3248

                                y: ob.origin.y - acc_old.1,

3249

},

3250

                            size: ob.size,

3251

};

3252

                        moved_union = Some(match moved_union {

3253

                            None => vr,

3254

                            Some(m) => union_rects(m, vr),

3255

});

3256

                        continue;

3257

3258

3259

2844

3260

2844

            if std::env::var_os("AZ_BLIT_DEBUG").is_some() {

3261

                eprintln!(

3262

                    "[dldiff] mismatch {:?} old_bounds={:?}",

3263

                    std::mem::discriminant(new_item),

3264

                    old_item.visual_bounds()

3265

);

3266

2844

3267

            // LCD text ink hangs ~2/3 of a device pixel outside the run's

3268

            // bounds on each side (the 5-tap FIR fringe). A MOVED run leaves

3269

            // stale fringe one pixel outside old∪new unless the damage covers

3270

            // it, and the repaint must CLEAR that pixel so the re-blend lands

3271

            // on base, not on retained ink. 1 LOGICAL px covers the fringe

3272

            // for every dpi ≥ 0.67 (0.67 × 1 px = the 2-stripe overhang).

3273

2844

            let fringe = if matches!(new_item, DisplayListItem::Text { .. }) {

3274

2696

1.0

3275

            } else {

3276

148

0.0

3277

};

3278

2844

            let inflate = |r: LogicalRect| LogicalRect {

3279

5688

                origin: LogicalPosition {

3280

5688

                    x: r.origin.x - fringe,

3281

5688

                    y: r.origin.y - fringe,

3282

5688

},

3283

5688

                size: LogicalSize {

3284

5688

                    width: 2.0f32.mul_add(fringe, r.size.width),

3285

5688

                    height: 2.0f32.mul_add(fringe, r.size.height),

3286

5688

},

3287

5688

};

3288

2844

            if let Some(ob) = old_item.visual_bounds() {

3289

2844

                damage.push(inflate(LogicalRect {

3290

2844

                    origin: LogicalPosition {

3291

2844

                        x: ob.origin.x - acc_old.0,

3292

2844

                        y: ob.origin.y - acc_old.1,

3293

2844

},

3294

2844

                    size: ob.size,

3295

2844

                }));

3296

2844

3297

2844

            if let Some(nb) = new_item.visual_bounds() {

3298

2844

                damage.push(inflate(LogicalRect {

3299

2844

                    origin: LogicalPosition {

3300

2844

                        x: nb.origin.x - acc_new.0,

3301

2844

                        y: nb.origin.y - acc_new.1,

3302

2844

},

3303

2844

                    size: nb.size,

3304

2844

                }));

3305

2844

3306

609507

3307

3308

3309

    // Coalesce overlapping rects

3310

955

    coalesce_damage_rects(&mut damage);

3311

955

    Some((damage, moved_union))

3312

1091

3313

3314

fn union_rects(a: LogicalRect, b: LogicalRect) -> LogicalRect {

3315

    let x0 = a.origin.x.min(b.origin.x);

3316

    let y0 = a.origin.y.min(b.origin.y);

3317

    let x1 = (a.origin.x + a.size.width).max(b.origin.x + b.size.width);

3318

    let y1 = (a.origin.y + a.size.height).max(b.origin.y + b.size.height);

3319

    LogicalRect {

3320

        origin: LogicalPosition { x: x0, y: y0 },

3321

        size: LogicalSize {

3322

            width: x1 - x0,

3323

            height: y1 - y0,

3324

},

3325

3326

3327

3328

/// Is `new` exactly `old` translated by `delta`? Uses `translate_item` on a

3329

/// clone + `is_visually_equal` — runs ONLY for mismatching pairs inside the

3330

/// hint region (the steady-state pair equals and never reaches this).

3331

#[must_use]

3332

pub fn items_equal_translated(

3333

    old: &DisplayListItem,

3334

    new: &DisplayListItem,

3335

    delta: (f32, f32),

3336

) -> bool {

3337

    use crate::solver3::display_list::translate_item;

3338

    let translated = translate_item(

3339

        old.clone(),

3340

        LogicalPosition {

3341

            x: delta.0,

3342

            y: delta.1,

3343

},

3344

);

3345

    translated.is_visually_equal(new)

3346

3347

3348

/// Are two display lists visually identical?

3349

///

3350

/// (same length, same item

3351

/// discriminants, every item `is_visually_equal`). Cheaper proxy than a

3352

/// structural hash, reusing the same per-item comparison the damage diff uses.

3353

#[must_use]

3354

9

pub fn display_lists_visually_equal(a: &DisplayList, b: &DisplayList) -> bool {

3355

9

    if a.items.len() != b.items.len() {

3356

1

        return false;

3357

8

3358

9

    a.items.iter().zip(b.items.iter()).all(|(x, y)| {

3359

9

        std::mem::discriminant(x) == std::mem::discriminant(y) && x.is_visually_equal(y)

3360

9

})

3361

9

3362

3363

/// Damage rects for `VirtualView` child DOMs whose content changed since the

3364

/// previous frame.

3365

///

3366

/// The parent display list only carries a `VirtualView { child_dom_id, bounds }`

3367

/// item that stays byte-identical when the *child* DOM re-renders (e.g. a

3368

/// `MapWidget` tile arriving on a worker thread and re-invoking the `VirtualView`

3369

/// in place). So `compute_display_list_damage` — which only diffs the parent —

3370

/// reports "nothing changed", and `render_frame` would skip the frame, freezing

3371

/// the child content. This compares each `VirtualView`'s child DL against the

3372

/// previous frame's and returns the on-screen bounds of every one that differs,

3373

/// so the caller can damage exactly those regions.

3374

///

3375

/// `current` / `previous` are keyed by the child `DomId` (the non-root entries

3376

/// of `layout_results`). A child that is newly present or newly absent counts

3377

/// as changed.

3378

#[must_use]

3379

16772

pub fn compute_virtual_view_damage(

3380

16772

    parent: &DisplayList,

3381

16772

    current: &std::collections::BTreeMap<azul_core::dom::DomId, std::sync::Arc<DisplayList>>,

3382

16772

    previous: &std::collections::BTreeMap<azul_core::dom::DomId, std::sync::Arc<DisplayList>>,

3383

16772

) -> Vec<LogicalRect> {

3384

16772

    let mut damage = Vec::new();

3385

316743

    for item in &parent.items {

3386

        if let DisplayListItem::VirtualView {

3387

8

            child_dom_id,

3388

8

            bounds,

3389

8

            content_offset,

3390

..

3391

299971

        } = item

3392

3393

8

            let view = *bounds.inner();

3394

8

            match (current.get(child_dom_id), previous.get(child_dom_id)) {

3395

5

                (Some(c), Some(p)) => {

3396

                    // Same Arc → definitely unchanged (cheap fast-path).

3397

5

                    if std::sync::Arc::ptr_eq(c, p) || display_lists_visually_equal(c, p) {

3398

2

                        continue;

3399

3

3400

3401

                    // SOMETHING changed - but WHAT. Damaging the whole view

3402

                    // here is what made a blinking caret cost a full-window

3403

                    // re-raster plus a full-window blit: AzWriter's document

3404

                    // body is a VirtualView, the caret lives in its child DOM,

3405

                    // and every 1200 ms tick reported `render=30ms blit=15ms`

3406

                    // on an otherwise idle X11/CPU window. The parent list has

3407

                    // had an item diff all along; the child never got one.

3408

//

3409

                    // Child lists are 0-relative (see the VirtualView arm in

3410

                    // raster.rs: the renderer draws at `pos - scroll`, with the

3411

                    // view origin and content offset pushed as the scroll), so

3412

                    // a diff rect at content (x, y) lands on screen at

3413

                    // `origin + (x, y) - content_offset`, clipped to the view.

3414

3

                    let empty = ScrollOffsetMap::default();

3415

3

                    match compute_display_list_damage(p, c, &empty, &empty) {

3416

                        // The diff paired every item and found the ones that

3417

                        // moved: repaint exactly those.

3418

3

                        Some(rects) if !rects.is_empty() => {

3419

3

                            let dx = view.origin.x - content_offset.x;

3420

3

                            let dy = view.origin.y - content_offset.y;

3421

6

                            for r in rects {

3422

3

                                let on_screen = LogicalRect {

3423

3

                                    origin: LogicalPosition {

3424

3

                                        x: r.origin.x + dx,

3425

3

                                        y: r.origin.y + dy,

3426

3

},

3427

3

                                    size: r.size,

3428

3

};

3429

3

                                let clipped = intersect_logical_rects(on_screen, view);

3430

                                // Scrolled out of sight: behind the view's clip,

3431

                                // so those pixels are a neighbour's, not ours.

3432

3

                                if clipped.size.width > 0.0 && clipped.size.height > 0.0 {

3433

2

                                    damage.push(clipped);

3434

2

3435

3436

3437

                        // The two answers disagree (visually different, but the

3438

                        // diff found nothing to repaint) or the diff gave up on

3439

                        // a structural change. Precision is an optimisation;

3440

                        // correctness is not, so fall back to the whole view.

3441

                        _ => damage.push(view),

3442

3443

3444

                // Appeared or disappeared this frame - nothing to diff against.

3445

2

                (Some(_), None) | (None, Some(_)) => damage.push(view),

3446

1

                (None, None) => {}

3447

3448

299963

3449

3450

16772

    damage

3451

16772

3452

3453

/// Merge overlapping or adjacent damage rects to reduce overdraw.

3454

#[allow(clippy::suboptimal_flops)] // mul_add not guaranteed faster/available without target +fma;

3455

                                   // keep explicit a*b+c

3456

1217

pub fn coalesce_damage_rects(rects: &mut Vec<LogicalRect>) {

3457

1217

    if rects.len() <= 1 {

3458

102

        return;

3459

1115

3460

3461

    // Simple O(n^2) merge — fine for typical damage counts (<20 rects)

3462

1115

    let mut changed = true;

3463

3526

    while changed {

3464

2411

        changed = false;

3465

2411

        let mut i = 0;

3466

6980

        while i < rects.len() {

3467

4569

            let mut j = i + 1;

3468

13431

            while j < rects.len() {

3469

                // 8 logical pixels: merge rects that are close enough to avoid

3470

                // many tiny damage regions that would cause redundant repaints —

3471

                // BUT only when the merged box doesn't balloon the repaint. Two

3472

                // PERPENDICULAR thin strips (e.g. a vertical + a horizontal

3473

                // scrollbar meeting at a corner) are "adjacent" yet their bounding

3474

                // box is the whole viewport: merging them turns ~3k px of overdraw

3475

                // into ~20k. Reject a merge whose union is much larger than the two

3476

                // rects combined; keep them separate instead.

3477

8862

                if rects_overlap_or_adjacent(&rects[i], &rects[j], 8.0) {

3478

6906

                    let u = union_rect(&rects[i], &rects[j]);

3479

6906

                    let area_u = (u.size.width * u.size.height).max(0.0);

3480

6906

                    let area_i = (rects[i].size.width * rects[i].size.height).max(0.0);

3481

6906

                    let area_j = (rects[j].size.width * rects[j].size.height).max(0.0);

3482

                    // 1.5× slack covers genuine overlap (union < sum) and small-gap

3483

                    // tiling (union ≈ sum) while rejecting perpendicular-strip bboxes.

3484

6906

                    if area_u <= (area_i + area_j) * 1.5 + 64.0 {

3485

4634

                        rects[i] = u;

3486

4634

                        rects.swap_remove(j);

3487

4634

                        changed = true;

3488

4634

                    } else {

3489

2272

                        j += 1;

3490

2272

3491

1956

                } else {

3492

1956

                    j += 1;

3493

1956

3494

3495

4569

            i += 1;

3496

3497

3498

1217

3499

3500

#[must_use]

3501

637126

pub fn rects_overlap_or_adjacent(a: &LogicalRect, b: &LogicalRect, gap: f32) -> bool {

3502

637126

    a.origin.x - gap <= b.origin.x + b.size.width

3503

635048

        && b.origin.x - gap <= a.origin.x + a.size.width

3504

634432

        && a.origin.y - gap <= b.origin.y + b.size.height

3505

21194

        && b.origin.y - gap <= a.origin.y + a.size.height

3506

637126

3507

3508

/// Compute damage rects for a grow-only window resize.

3509

/// Returns the right strip and bottom strip that need rendering.

3510

#[must_use]

3511

15

pub fn compute_resize_damage(

3512

15

    old_width: f32,

3513

15

    old_height: f32,

3514

15

    new_width: f32,

3515

15

    new_height: f32,

3516

15

) -> Vec<LogicalRect> {

3517

15

    let mut rects = Vec::new();

3518

15

    if new_width > old_width {

3519

10

        rects.push(LogicalRect {

3520

10

            origin: LogicalPosition {

3521

10

                x: old_width,

3522

10

                y: 0.0,

3523

10

},

3524

10

            size: LogicalSize {

3525

10

                width: new_width - old_width,

3526

10

                height: new_height,

3527

10

},

3528

10

});

3529

12

3530

15

    if new_height > old_height {

3531

6

        rects.push(LogicalRect {

3532

6

            origin: LogicalPosition {

3533

6

                x: 0.0,

3534

6

                y: old_height,

3535

6

},

3536

6

            size: LogicalSize {

3537

6

                width: old_width.min(new_width),

3538

6

                height: new_height - old_height,

3539

6

},

3540

6

});

3541

9

3542

15

    rects

3543

15

3544

3545

/// Compare a rectangular sub-region of two pixmaps pixel-by-pixel.

3546

/// Returns the number of pixels that differ by more than `threshold` per channel.

3547

#[allow(clippy::cast_possible_truncation)] // bounded pixel/coord/colour/glyph cast

3548

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

3549

#[must_use]

3550

19

pub fn compare_region(

3551

19

    a: &AzulPixmap,

3552

19

    b: &AzulPixmap,

3553

19

    x: u32,

3554

19

    y: u32,

3555

19

    w: u32,

3556

19

    h: u32,

3557

19

    threshold: u8,

3558

19

) -> usize {

3559

19

    let mut diff_count = 0;

3560

2026

    for row in y..(y + h).min(a.height).min(b.height) {

3561

400100

        for col in x..(x + w).min(a.width).min(b.width) {

3562

400100

            let ai = (row * a.width + col) as usize * 4;

3563

400100

            let bi = (row * b.width + col) as usize * 4;

3564

400100

            if ai + 3 >= a.data.len() || bi + 3 >= b.data.len() {

3565

                continue;

3566

400100

3567

400100

            let dr = (i16::from(a.data[ai]) - i16::from(b.data[bi])).unsigned_abs() as u8;

3568

400100

            let dg = (i16::from(a.data[ai + 1]) - i16::from(b.data[bi + 1])).unsigned_abs() as u8;

3569

400100

            let db = (i16::from(a.data[ai + 2]) - i16::from(b.data[bi + 2])).unsigned_abs() as u8;

3570

400100

            if dr > threshold || dg > threshold || db > threshold {

3571

52

                diff_count += 1;

3572

400052

3573

3574

3575

19

    diff_count

3576

19

3577

3578

/// Layout-driven layer offsets snap to whole device pixels so layers take the integer blit instead of being resampled.

3579

#[inline]

3580

432

fn layout_offset_device_px(logical: f32, dpi: f64) -> f64 {

3581

432

    (f64::from(logical) * dpi).round()

3582

432

3583

3584

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

3585

// scroll_shift_region — unit tests (#14 single-axis, #16 diagonal pan)

3586

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

3587

3588

#[cfg(test)]

3589

mod layer_size_is_never_an_allocation_bomb {

3590

    use azul_core::geom::LogicalSize;

3591

3592

    use super::*;

3593

3594

10

    fn sz(w: f32, h: f32) -> LogicalSize {

3595

10

        LogicalSize::new(w, h)

3596

10

3597

3598

    #[test]

3599

1

    fn an_infinite_size_is_not_a_size() {

3600

        // `as u32` saturates, so this used to be u32::MAX — and the caller then

3601

        // asked for u32::MAX * height * 4 bytes.

3602

1

        assert_eq!(layer_pixel_size(sz(f32::INFINITY, 27.0), 2.0, None), (0, 0));

3603

1

        assert_eq!(

3604

1

            layer_pixel_size(sz(100.0, f32::INFINITY), 2.0, None),

3605

            (0, 0)

3606

);

3607

1

        assert_eq!(layer_pixel_size(sz(f32::NAN, 27.0), 2.0, None), (0, 0));

3608

1

        assert_eq!(layer_pixel_size(sz(100.0, 27.0), f32::NAN, None), (0, 0));

3609

1

3610

3611

    #[test]

3612

1

    fn a_finite_but_absurd_size_is_clamped_rather_than_saturated() {

3613

        // Finite overflow is the same bomb with an extra step: 1e30 * 2 still

3614

        // saturates the cast.

3615

1

        assert_eq!(

3616

1

            layer_pixel_size(sz(1e30, 27.0), 2.0, None),

3617

            (MAX_LAYER_DIM, 54),

3618

);

3619

1

3620

3621

    #[test]

3622

1

    fn a_non_positive_extent_is_zero_not_a_wrapped_huge_number() {

3623

        // `-5.0 as u32` is 0 today, but only because the cast saturates at the

3624

        // bottom too — state it, so a future refactor cannot turn it negative.

3625

1

        assert_eq!(layer_pixel_size(sz(-5.0, 27.0), 2.0, None), (0, 54));

3626

1

        assert_eq!(layer_pixel_size(sz(0.0, 0.0), 2.0, None), (0, 0));

3627

1

3628

3629

    #[test]

3630

1

    fn ordinary_sizes_are_unchanged_by_the_guard() {

3631

        // The guard must be invisible to every layout that was already fine,

3632

        // rounding up exactly as the old cast did.

3633

1

        assert_eq!(layer_pixel_size(sz(1000.0, 730.0), 2.0, None), (2000, 1460));

3634

1

        assert_eq!(layer_pixel_size(sz(27.5, 13.5), 2.0, None), (55, 27));

3635

1

        assert_eq!(layer_pixel_size(sz(1.0, 1.0), 1.0, None), (1, 1));

3636

1

3637

3638

3639

#[cfg(test)]

3640

mod translate_hint_contract {

3641

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

3642

3643

    use super::*;

3644

    use crate::solver3::display_list::PatchMoveSummary;

3645

3646

7

    fn mv(dx: f32, dy: f32) -> PatchMoveSummary {

3647

7

        let r = LogicalRect::new(

3648

7

            LogicalPosition::new(0.0, 0.0),

3649

7

            LogicalSize::new(100.0, 100.0),

3650

);

3651

7

        PatchMoveSummary {

3652

7

            dominant_delta: LogicalPosition::new(dx, dy),

3653

7

            mover_rects_old: vec![r],

3654

7

            moved_region_old: r,

3655

7

            exceptions: Vec::new(),

3656

7

3657

7

3658

3659

    /// A fractional physical delta must NOT blit: it would change every

3660

    /// subpixel phase, so the frame has to re-render.

3661

    #[test]

3662

1

    fn a_fractional_delta_is_not_blittable() {

3663

1

        assert!(translate_hint_for_patch(Some(&mv(0.0, 10.5)), 1.0, true, false, false).is_none());

3664

        // ... but the SAME logical delta at 2x dpi is integral in physical px.

3665

1

        assert!(translate_hint_for_patch(Some(&mv(0.0, 10.5)), 2.0, true, false, false).is_some());

3666

1

3667

3668

    /// A sub-pixel move is not a move.

3669

    #[test]

3670

1

    fn a_delta_that_moves_no_physical_pixel_is_not_blittable() {

3671

1

        assert!(translate_hint_for_patch(Some(&mv(0.0, 0.0)), 1.0, true, false, false).is_none());

3672

1

3673

3674

    /// The two guards that make a blit safe at all.

3675

    #[test]

3676

1

    fn an_untrustworthy_previous_frame_or_a_second_shift_is_refused() {

3677

1

        assert!(translate_hint_for_patch(Some(&mv(0.0, 12.0)), 1.0, true, false, false).is_some());

3678

        // previous frame cannot be reused -> no source pixels to blit

3679

1

        assert!(translate_hint_for_patch(Some(&mv(0.0, 12.0)), 1.0, false, false, false).is_none());

3680

        // this display list was already shifted -> shifting twice doubles it

3681

1

        assert!(translate_hint_for_patch(Some(&mv(0.0, 12.0)), 1.0, true, true, false).is_none());

3682

1

3683

3684

    /// No patch, no hint.

3685

    #[test]

3686

1

    fn no_patch_move_means_no_hint() {

3687

1

        assert!(translate_hint_for_patch(None, 1.0, true, false, false).is_none());

3688

        // Content-space movers are only valid at zero scroll: any active

3689

        // offset must kill the blit (the memmove would garble scrolled

3690

        // content) and fall back to plain damage.

3691

1

        assert!(translate_hint_for_patch(Some(&mv(0.0, 12.0)), 1.0, true, false, true).is_none());

3692

1

3693

3694

3695

#[cfg(test)]

3696

mod scroll_shift_tests {

3697

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

3698

3699

    use super::*;

3700

3701

    /// Pixmap where every pixel encodes its own coords: R = x&0xFF, G = y&0xFF.

3702

    /// After a shift, a pixel's (R,G) tells you which source pixel landed there,

3703

    /// so we can assert the move is an exact translation.

3704

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

3705

                                             // names

3706

5

    fn xy_pixmap(w: u32, h: u32) -> AzulPixmap {

3707

5

        let mut p = AzulPixmap::new(w, h).unwrap();

3708

5

        let d = p.data_mut();

3709

428

        for y in 0..h {

3710

68192

            for x in 0..w {

3711

68192

                let i = ((y * w + x) * 4) as usize;

3712

68192

                d[i] = (x & 0xFF) as u8;

3713

68192

                d[i + 1] = (y & 0xFF) as u8;

3714

68192

                d[i + 2] = 0;

3715

68192

                d[i + 3] = 255;

3716

68192

3717

3718

5

3719

5

3720

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

3721

                                             // names

3722

10

    fn at(p: &AzulPixmap, x: u32, y: u32) -> [u8; 4] {

3723

10

        let w = p.width();

3724

10

        let d = p.data();

3725

10

        let i = ((y * w + x) * 4) as usize;

3726

10

        [d[i], d[i + 1], d[i + 2], d[i + 3]]

3727

10

3728

33

    fn rect(x: f32, y: f32, w: f32, h: f32) -> LogicalRect {

3729

33

        LogicalRect {

3730

33

            origin: LogicalPosition::new(x, y),

3731

33

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

3732

33

3733

33

3734

3735

    /// #32 LAW: on a pool-order (B,G,R,A) target, shift + commit-swizzle must

3736

    /// leave the moved pixels byte-identical to a PLAIN byte-move of the slot

3737

    /// — a pure move never changes displayed colors. The pool-order variant

3738

    /// un-swizzles the moved block so the commit swizzle re-converts it; the

3739

    /// shipped bug (plain variant + commit swizzle) double-converts and paints

3740

    /// scrolled content with R and B swapped (see the NC below).

3741

    #[test]

3742

1

    fn pool_order_shift_then_commit_swizzle_is_a_pure_byte_move() {

3743

1

        let (w, h) = (32u32, 32u32);

3744

1

        let clip = rect(0.0, 0.0, 32.0, 32.0);

3745

2

        let mk = || {

3746

2

            let mut p = AzulPixmap::new(w, h).unwrap();

3747

2

            let d = p.data_mut();

3748

64

            for y in 0..h as usize {

3749

2048

                for x in 0..w as usize {

3750

2048

                    let o = (y * w as usize + x) * 4;

3751

2048

                    d[o] = (10 + x) as u8; // R

3752

2048

                    d[o + 1] = (100 + y) as u8; // G

3753

2048

                    d[o + 2] = (200 - x) as u8; // B (never equals R)

3754

2048

                    d[o + 3] = 255;

3755

2048

3756

3757

2

3758

2

};

3759

3

        let swizzle_all = |p: &mut AzulPixmap| {

3760

3

            let d = p.data_mut();

3761

3072

            for o in (0..d.len()).step_by(4) {

3762

3072

                d.swap(o, o + 2);

3763

3072

3764

3

};

3765

3766

        // Simulated committed slot: pattern in POOL order.

3767

1

        let mut slot = mk();

3768

1

        swizzle_all(&mut slot);

3769

        // Reference: a plain byte-move of the same slot (what the compositor

3770

        // must end up displaying — a move never recolors).

3771

1

        let mut reference = mk();

3772

1

        swizzle_all(&mut reference);

3773

1

        let ref_strips =

3774

1

            scroll_shift_region_exact(&mut reference, &clip, (0.0, 8.0), (0.0, 8.0), 1.0);

3775

3776

        // Production path: pool-order shift, then the commit swizzle over the

3777

        // whole presented clip.

3778

1

        let strips =

3779

1

            scroll_shift_region_exact_pool_order(&mut slot, &clip, (0.0, 8.0), (0.0, 8.0), 1.0);

3780

1

        assert_eq!(

3781

            strips, ref_strips,

3782

            "both variants must expose the same strips"

3783

);

3784

1

        swizzle_all(&mut slot); // the commit swizzle (full clip = full pixmap here)

3785

3786

1024

        let in_strip = |x: usize, y: usize| {

3787

1024

            strips.iter().any(|r| {

3788

1024

                (x as f32) >= r.origin.x

3789

1024

                    && (x as f32) < r.origin.x + r.size.width

3790

1024

                    && (y as f32) >= r.origin.y

3791

256

                    && (y as f32) < r.origin.y + r.size.height

3792

1024

})

3793

1024

};

3794

1

        let (a, b) = (slot.data(), reference.data());

3795

32

        for y in 0..h as usize {

3796

1024

            for x in 0..w as usize {

3797

1024

                if in_strip(x, y) {

3798

256

                    continue; // strips are repainted fresh in production

3799

768

3800

768

                let o = (y * w as usize + x) * 4;

3801

768

                assert_eq!(

3802

768

                    &a[o..o + 4],

3803

768

                    &b[o..o + 4],

3804

                    "moved pixel recolored at {x},{y} — the double-swizzle bug"

3805

);

3806

3807

3808

1

3809

3810

    /// NEGATIVE CONTROL for the law above: the SHIPPED-BUG combination (plain

3811

    /// shift + commit swizzle) must DIFFER from the pure byte-move in the

3812

    /// moved region — proving the law's comparison can fail. If this ever

3813

    /// passes with equality, the fixture can no longer express the bug and

3814

    /// the law is vacuous.

3815

    #[test]

3816

1

    fn nc_plain_shift_then_commit_swizzle_recolors_moved_pixels() {

3817

1

        let (w, h) = (32u32, 32u32);

3818

1

        let clip = rect(0.0, 0.0, 32.0, 32.0);

3819

3

        let mk = || {

3820

3

            let mut p = AzulPixmap::new(w, h).unwrap();

3821

3

            let d = p.data_mut();

3822

96

            for y in 0..h as usize {

3823

3072

                for x in 0..w as usize {

3824

3072

                    let o = (y * w as usize + x) * 4;

3825

3072

                    d[o] = (10 + x) as u8;

3826

3072

                    d[o + 1] = (100 + y) as u8;

3827

3072

                    d[o + 2] = (200 - x) as u8;

3828

3072

                    d[o + 3] = 255;

3829

3072

3830

3831

3

3832

3

};

3833

4

        let swizzle_all = |p: &mut AzulPixmap| {

3834

4

            let d = p.data_mut();

3835

4096

            for o in (0..d.len()).step_by(4) {

3836

4096

                d.swap(o, o + 2);

3837

4096

3838

4

};

3839

1

        let mut slot = mk();

3840

1

        swizzle_all(&mut slot);

3841

1

        let mut reference = mk();

3842

1

        swizzle_all(&mut reference);

3843

1

        let strips = scroll_shift_region_exact(&mut reference, &clip, (0.0, 8.0), (0.0, 8.0), 1.0);

3844

3845

1

        let mut buggy = mk();

3846

1

        swizzle_all(&mut buggy);

3847

1

        let _ = scroll_shift_region_exact(&mut buggy, &clip, (0.0, 8.0), (0.0, 8.0), 1.0);

3848

1

        swizzle_all(&mut buggy); // commit swizzle double-converts the moved block

3849

3850

1024

        let in_strip = |x: usize, y: usize| {

3851

1024

            strips.iter().any(|r| {

3852

1024

                (x as f32) >= r.origin.x

3853

1024

                    && (x as f32) < r.origin.x + r.size.width

3854

1024

                    && (y as f32) >= r.origin.y

3855

256

                    && (y as f32) < r.origin.y + r.size.height

3856

1024

})

3857

1024

};

3858

1

        let (a, b) = (buggy.data(), reference.data());

3859

1

        let mut differs = 0usize;

3860

32

        for y in 0..h as usize {

3861

1024

            for x in 0..w as usize {

3862

1024

                if in_strip(x, y) {

3863

256

                    continue;

3864

768

3865

768

                let o = (y * w as usize + x) * 4;

3866

768

                if a[o..o + 4] != b[o..o + 4] {

3867

768

                    differs += 1;

3868

768

3869

3870

3871

1

        assert!(

3872

1

            differs > 0,

3873

            "the buggy combination did not recolor anything — the law above is vacuous"

3874

);

3875

1

3876

3877

    #[test]

3878

1

    fn noop_when_delta_zero() {

3879

1

        let mut p = xy_pixmap(64, 64);

3880

1

        let strips = scroll_shift_region(

3881

1

            &mut p,

3882

1

            &rect(0.0, 0.0, 64.0, 64.0),

3883

1

            (0.0, 0.0),

3884

1

            (0.0, 0.0),

3885

            1.0,

3886

);

3887

1

        assert!(

3888

1

            strips.is_empty(),

3889

            "zero delta must not shift or expose anything"

3890

);

3891

        // Buffer untouched.

3892

1

        assert_eq!(at(&p, 10, 20), [10, 20, 0, 255]);

3893

1

3894

3895

    #[test]

3896

    #[allow(clippy::float_cmp)] // intentional exact compare: change-detection / identity fast-path

3897

                                // / cache-key match

3898

1

    fn vertical_scroll_one_strip_and_translates() {

3899

1

        let mut p = xy_pixmap(200, 100);

3900

        // Scroll DOWN by 30 → content moves UP → bottom strip exposed.

3901

1

        let strips = scroll_shift_region(

3902

1

            &mut p,

3903

1

            &rect(0.0, 0.0, 200.0, 100.0),

3904

1

            (0.0, 30.0),

3905

1

            (0.0, 30.0),

3906

            1.0,

3907

);

3908

1

        assert_eq!(

3909

1

            strips.len(),

3910

1,

3911

            "single-axis scroll = one strip, got {strips:?}"

3912

);

3913

1

        let s = &strips[0];

3914

1

        assert!(

3915

1

            (s.origin.y - (100.0 - s.size.height)).abs() < 0.01 && s.size.width == 200.0,

3916

            "vertical scroll-down must expose a full-width BOTTOM strip, got {s:?}"

3917

);

3918

        // Kept region (top): (x, y) now holds original (x, y+30).

3919

1

        assert_eq!(

3920

1

            at(&p, 50, 10),

3921

            [50, 40, 0, 255],

3922

            "content not translated up by 30"

3923

);

3924

1

3925

3926

    #[test]

3927

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

3928

    #[allow(clippy::float_cmp)] // intentional exact compare: change-detection / identity fast-path

3929

                                // / cache-key match

3930

1

    fn diagonal_pan_two_strips_and_translates() {

3931

1

        let mut p = xy_pixmap(200, 100);

3932

        // Diagonal scroll down-right by (20, 30): content moves up-left.

3933

1

        let strips = scroll_shift_region(

3934

1

            &mut p,

3935

1

            &rect(0.0, 0.0, 200.0, 100.0),

3936

1

            (20.0, 30.0),

3937

1

            (20.0, 30.0),

3938

            1.0,

3939

);

3940

1

        assert_eq!(

3941

1

            strips.len(),

3942

2,

3943

            "diagonal pan must expose TWO strips (L-shape), got {strips:?}"

3944

);

3945

        // One full-width strip (the vertical move) + one full-height strip (horizontal).

3946

1

        let has_h_strip = strips.iter().any(|s| s.size.width == 200.0);

3947

2

        let has_v_strip = strips.iter().any(|s| s.size.height == 100.0);

3948

1

        assert!(

3949

1

            has_h_strip && has_v_strip,

3950

            "expected a full-width AND a full-height strip, got {strips:?}"

3951

);

3952

        // Kept top-left region: (sx,sy) now holds original (sx+20, sy+30).

3953

        // (50,40) is inside the kept block (bottom strip y>=69, right strip x>=179).

3954

1

        let got = at(&p, 50, 40);

3955

1

        assert_eq!(got[0], 70, "x not translated left by 20 (R channel)");

3956

1

        assert_eq!(got[1], 70, "y not translated up by 30 (G channel)");

3957

1

3958

3959

    #[test]

3960

1

    fn shift_only_touches_inside_clip() {

3961

1

        let mut p = xy_pixmap(200, 100);

3962

        // Clip is a sub-region; everything OUTSIDE must be byte-identical after.

3963

1

        let clip = rect(8.0, 16.0, 180.0, 60.0); // phys [8,188) x [16,76)

3964

1

        drop(scroll_shift_region(

3965

1

            &mut p,

3966

1

            &clip,

3967

1

            (0.0, 10.0),

3968

1

            (0.0, 10.0),

3969

            1.0,

3970

));

3971

7

        for &(x, y) in &[

3972

7

            (0u32, 0u32),

3973

7

            (199, 99),

3974

7

            (100, 5),

3975

7

            (100, 90),

3976

7

            (2, 50),

3977

7

            (190, 50),

3978

7

] {

3979

6

            assert_eq!(

3980

6

                at(&p, x, y),

3981

6

                [(x & 0xFF) as u8, (y & 0xFF) as u8, 0, 255],

3982

                "pixel ({x},{y}) OUTSIDE the clip was modified — scroll leaked past its frame"

3983

);

3984

3985

        // Inside the kept region it DID move: (50,40) holds original (50,50).

3986

1

        assert_eq!(

3987

1

            at(&p, 50, 40),

3988

            [50, 50, 0, 255],

3989

            "inside-clip content not shifted"

3990

);

3991

1

3992

3993

    #[test]

3994

    #[allow(clippy::float_cmp)] // test asserts exact float equality on deterministic values

3995

1

    fn shift_larger_than_region_returns_full_clip() {

3996

1

        let mut p = xy_pixmap(64, 64);

3997

1

        let clip = rect(0.0, 0.0, 64.0, 64.0);

3998

        // Shift exceeds the region height → whole clip exposed (no partial strip).

3999

1

        let strips = scroll_shift_region(&mut p, &clip, (0.0, 100.0), (0.0, 100.0), 1.0);

4000

1

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

4001

1

        assert_eq!(strips[0].size.width, 64.0);

4002

1

        assert_eq!(strips[0].size.height, 64.0);

4003

1

4004

4005

    // --- #20 fast-path eligibility ---

4006

    use azul_css::props::basic::color::ColorU;

4007

4008

    use crate::solver3::display_list::{

4009

        BorderRadius, DisplayList, DisplayListItem, WindowLogicalRect,

4010

};

4011

4012

5

    fn dl(items: Vec<DisplayListItem>) -> DisplayList {

4013

5

        DisplayList {

4014

5

            items,

4015

5

            node_mapping: Vec::new(),

4016

5

            forced_page_breaks: Vec::new(),

4017

5

            fixed_position_item_ranges: Vec::new(),

4018

5

            layout_node_mapping: Vec::new(),

4019

5

            uniform_text_bgs: Vec::new(),

4020

5

            text_selection_colors: Vec::new(),

4021

5

4022

5

4023

15

    fn wr(x: f32, y: f32, w: f32, h: f32) -> WindowLogicalRect {

4024

15

        rect(x, y, w, h).into()

4025

15

4026

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

4027

                                             // names

4028

10

    fn fill(x: f32, y: f32, w: f32, h: f32, a: u8) -> DisplayListItem {

4029

10

        DisplayListItem::Rect {

4030

10

            bounds: wr(x, y, w, h),

4031

10

            color: ColorU {

4032

10

                r: 10,

4033

10

                g: 20,

4034

10

                b: 30,

4035

10

a,

4036

10

},

4037

10

            border_radius: BorderRadius::default(),

4038

10

4039

10

4040

5

    fn scroll_frame(id: u64) -> DisplayListItem {

4041

5

        DisplayListItem::PushScrollFrame {

4042

5

            clip_bounds: wr(0.0, 0.0, 100.0, 100.0),

4043

5

            content_size: LogicalSize::new(100.0, 1000.0),

4044

5

            scroll_id: id,

4045

5

4046

5

4047

4048

    #[test]

4049

1

    fn eligible_when_no_backdrop_even_if_transparent() {

4050

        // Transparent content, but nothing painted behind the frame → safe.

4051

1

        let list = dl(vec![

4052

1

            scroll_frame(7),

4053

1

            fill(0.0, 0.0, 100.0, 30.0, 0), // transparent row

4054

1

            DisplayListItem::PopScrollFrame,

4055

]);

4056

1

        assert!(scroll_fast_path_eligible(

4057

1

            &list,

4058

7,

4059

1

            &rect(0.0, 0.0, 100.0, 100.0),

4060

1

            (0.0, 0.0),

4061

1

            (0.0, 0.0)

4062

));

4063

1

4064

4065

    #[test]

4066

1

    fn eligible_when_backdrop_is_single_uniform_colour() {

4067

        // A SINGLE flat colour covering the whole clip behind transparent content

4068

        // drags invisibly (same colour everywhere) → aggressive policy keeps the

4069

        // fast path. (This is the common body/container background case.)

4070

1

        let list = dl(vec![

4071

1

            fill(0.0, 0.0, 100.0, 100.0, 255), // one flat colour covering the clip

4072

1

            scroll_frame(7),

4073

1

            fill(0.0, 0.0, 100.0, 30.0, 0), // transparent content

4074

1

            DisplayListItem::PopScrollFrame,

4075

]);

4076

1

        assert!(scroll_fast_path_eligible(

4077

1

            &list,

4078

7,

4079

1

            &rect(0.0, 0.0, 100.0, 100.0),

4080

1

            (0.0, 0.0),

4081

1

            (0.0, 0.0)

4082

));

4083

1

4084

4085

    #[test]

4086

1

    fn ineligible_when_backdrop_is_non_uniform() {

4087

        // Two DIFFERENT colours behind transparent content → dragging them is

4088

        // visible → must full-repaint.

4089

1

        let mut left = fill(0.0, 0.0, 50.0, 100.0, 255);

4090

1

        if let DisplayListItem::Rect { color, .. } = &mut left {

4091

1

            *color = ColorU {

4092

1

                r: 200,

4093

1

                g: 0,

4094

1

                b: 0,

4095

1

                a: 255,

4096

1

};

4097

1

4098

1

        let mut right = fill(50.0, 0.0, 50.0, 100.0, 255);

4099

1

        if let DisplayListItem::Rect { color, .. } = &mut right {

4100

1

            *color = ColorU {

4101

1

                r: 0,

4102

1

                g: 0,

4103

1

                b: 200,

4104

1

                a: 255,

4105

1

};

4106

1

4107

1

        let list = dl(vec![

4108

1

            left,

4109

1

            right,

4110

1

            scroll_frame(7),

4111

1

            fill(0.0, 0.0, 100.0, 30.0, 0), // transparent content

4112

1

            DisplayListItem::PopScrollFrame,

4113

]);

4114

1

        assert!(!scroll_fast_path_eligible(

4115

1

            &list,

4116

1

7,

4117

1

            &rect(0.0, 0.0, 100.0, 100.0),

4118

1

            (0.0, 0.0),

4119

1

            (0.0, 0.0)

4120

1

));

4121

1

4122

4123

    #[test]

4124

1

    fn ineligible_when_single_colour_only_partly_covers() {

4125

        // One flat colour that covers only PART of the clip (rest is clear): its

4126

        // edge against the clear would drag visibly → full-repaint.

4127

1

        let list = dl(vec![

4128

1

            fill(0.0, 0.0, 100.0, 40.0, 255), // covers only the top 40px

4129

1

            scroll_frame(7),

4130

1

            fill(0.0, 0.0, 100.0, 30.0, 0), // transparent content

4131

1

            DisplayListItem::PopScrollFrame,

4132

]);

4133

1

        assert!(!scroll_fast_path_eligible(

4134

1

            &list,

4135

1

7,

4136

1

            &rect(0.0, 0.0, 100.0, 100.0),

4137

1

            (0.0, 0.0),

4138

1

            (0.0, 0.0)

4139

1

));

4140

1

4141

4142

    #[test]

4143

1

    fn eligible_when_backdrop_but_opaque_content_covers() {

4144

        // Backdrop behind, but the scrolling content opaquely covers the clip →

4145

        // nothing behind ever shows through → fast path is safe.

4146

1

        let list = dl(vec![

4147

1

            fill(0.0, 0.0, 100.0, 100.0, 255), // backdrop

4148

1

            scroll_frame(7),

4149

1

            fill(0.0, 0.0, 100.0, 1000.0, 255), // opaque full-content cover

4150

1

            DisplayListItem::PopScrollFrame,

4151

]);

4152

1

        assert!(scroll_fast_path_eligible(

4153

1

            &list,

4154

7,

4155

1

            &rect(0.0, 0.0, 100.0, 100.0),

4156

1

            (0.0, 0.0),

4157

1

            (0.0, 0.0)

4158

));

4159

1

4160

4161

    #[test]

4162

1

    fn rect_covered_by_detects_gap() {

4163

1

        let target = rect(0.0, 0.0, 100.0, 100.0);

4164

        // Single full cover.

4165

1

        assert!(rect_covered_by(&target, &[rect(0.0, 0.0, 100.0, 100.0)]));

4166

        // Two halves tile it.

4167

1

        assert!(rect_covered_by(

4168

1

            &target,

4169

1

            &[rect(0.0, 0.0, 100.0, 50.0), rect(0.0, 50.0, 100.0, 50.0)]

4170

));

4171

        // A gap in the middle is NOT covered.

4172

1

        assert!(!rect_covered_by(

4173

1

            &target,

4174

1

            &[rect(0.0, 0.0, 100.0, 40.0), rect(0.0, 60.0, 100.0, 40.0)]

4175

1

));

4176

        // Empty → not covered.

4177

1

        assert!(!rect_covered_by(&target, &[]));

4178

1

4179

4180

4181

#[cfg(test)]

4182

mod backdrop_filter_tests {

4183

    use super::*;

4184

4185

    /// The CPU renderer resolves every glyph run through a `FontManager` — there is

4186

    /// no second font table. These display lists carry no text, so an empty manager

4187

    /// is the honest input; a text-bearing test must register its face here.

4188

1

    fn test_font_manager() -> FontManager<FontRef> {

4189

1

        FontManager::new(rust_fontconfig::FcFontCache::default()).expect("FontManager::new")

4190

1

4191

4192

    use azul_core::resources::RendererResources;

4193

    use azul_css::props::{

4194

        basic::{length::PercentageValue, ColorU},

4195

        style::filter::StyleFilter,

4196

};

4197

4198

    use crate::{

4199

        cpurender::{CpuRenderState, ScrollOffsetMap},

4200

        solver3::display_list::DisplayList,

4201

};

4202

4203

2

    fn lrect(x: f32, y: f32, w: f32, h: f32) -> LogicalRect {

4204

2

        LogicalRect {

4205

2

            origin: LogicalPosition::new(x, y),

4206

2

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

4207

2

4208

2

4209

    // p/x/y/w/d/i are the conventional pixel-access short names

4210

    #[allow(clippy::many_single_char_names)]

4211

2

    fn px(p: &AzulPixmap, x: u32, y: u32) -> [u8; 4] {

4212

2

        let w = p.width();

4213

2

        let d = p.data();

4214

2

        let i = ((y * w + x) * 4) as usize;

4215

2

        [d[i], d[i + 1], d[i + 2], d[i + 3]]

4216

2

4217

4218

    /// A `backdrop-filter: invert(100%)` must invert the already-composited

4219

    /// backdrop under the element, while leaving pixels outside the element box

4220

    /// untouched.

4221

    #[test]

4222

1

    fn backdrop_filter_inverts_backdrop_region() {

4223

1

        let w = 100u32;

4224

1

        let h = 100u32;

4225

4226

        // Background: a solid blue rect over the whole canvas (root layer).

4227

        // Then a backdrop-filter:invert region over the right half (no own

4228

        // content), so its backdrop (blue) becomes inverted (yellow).

4229

1

        let blue = ColorU {

4230

1

            r: 0,

4231

1

            g: 0,

4232

1

            b: 255,

4233

1

            a: 255,

4234

1

};

4235

1

        let dl = DisplayList {

4236

1

            items: vec![

4237

1

                DisplayListItem::Rect {

4238

1

                    bounds: lrect(0.0, 0.0, 100.0, 100.0).into(),

4239

1

                    color: blue,

4240

1

                    border_radius: BorderRadius::default(),

4241

1

},

4242

1

                DisplayListItem::PushBackdropFilter {

4243

1

                    bounds: lrect(50.0, 0.0, 50.0, 100.0).into(),

4244

1

                    filters: vec![StyleFilter::Invert(PercentageValue::new(100.0))],

4245

1

},

4246

1

                DisplayListItem::PopBackdropFilter,

4247

1

],

4248

1

            ..Default::default()

4249

1

};

4250

4251

1

        let mut comp = CompositorState::new(w, h);

4252

1

        comp.allocate_layers_from_display_list(&dl, 1.0, &HashMap::new(), &HashMap::new());

4253

4254

        // A backdrop-filter layer must have been allocated.

4255

1

        assert!(

4256

1

            comp.layers.values().any(|l| l.is_backdrop_filter),

4257

            "no backdrop-filter layer allocated"

4258

);

4259

4260

1

        let rr = RendererResources::default();

4261

1

        let mut gc = GlyphCache::new();

4262

1

        let state = CpuRenderState::new(ScrollOffsetMap::new());

4263

1

        comp.render_layers(&dl, 1.0, &rr, &test_font_manager(), &mut gc, &state)

4264

1

            .unwrap();

4265

4266

1

        let mut out = AzulPixmap::new(w, h).unwrap();

4267

1

        out.fill(0, 0, 0, 255);

4268

1

        comp.composite_frame(&mut out, 1.0);

4269

4270

        // Left half: untouched blue backdrop.

4271

1

        let left = px(&out, 10, 50);

4272

1

        assert_eq!(left, [0, 0, 255, 255], "left half should stay blue");

4273

4274

        // Right half: blue inverted -> (255,255,0).

4275

1

        let right = px(&out, 75, 50);

4276

1

        assert!(

4277

1

            right[0] > 200 && right[1] > 200 && right[2] < 60,

4278

            "right half backdrop should be inverted to yellow, got {right:?}"

4279

);

4280

1

4281

4282

4283

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

4284

// Adversarial unit tests (autotest fleet)

4285

//

4286

// Focus: the compositor's numeric edges — NaN/inf/negative/zero `dpi_factor`,

4287

// saturating float→int casts, clip/region clamping, damage-rect arithmetic and

4288

// the malformed-display-list paths that the doc comments claim panic.

4289

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

4290

#[cfg(test)]

4291

#[allow(clippy::float_cmp)] // deterministic float values: exact compare is the assertion

4292

#[allow(clippy::many_single_char_names)] // domain-standard coordinate/pixel short names

4293

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

4294

#[allow(

4295

    clippy::cast_possible_truncation,

4296

    clippy::cast_precision_loss,

4297

    clippy::cast_sign_loss

4298

)]

4299

mod autotest_generated {

4300

4301

    /// The CPU renderer resolves every glyph run through a `FontManager` — there is

4302

    /// no second font table. These display lists carry no text, so an empty manager

4303

    /// is the honest input; a text-bearing test must register its face here.

4304

    fn test_font_manager() -> FontManager<FontRef> {

4305

        FontManager::new(rust_fontconfig::FcFontCache::default()).expect("FontManager::new")

4306

4307

    use std::{

4308

        collections::{BTreeMap, BTreeSet, HashMap},

4309

        sync::Arc,

4310

};

4311

4312

    use azul_core::{

4313

        dom::DomId,

4314

        resources::{RendererResources, TransformKey},

4315

        transform::ComputedTransform3D,

4316

};

4317

    use azul_css::props::{

4318

        basic::{angle::AngleValue, color::ColorU, length::PercentageValue, pixel::PixelValue},

4319

        style::filter::{StyleBlur, StyleFilter},

4320

};

4321

4322

    use super::*;

4323

    use crate::{

4324

        cpurender::{CpuRenderState, ScrollOffsetMap},

4325

        solver3::display_list::{BorderRadius, DisplayList, DisplayListItem, WindowLogicalRect},

4326

};

4327

4328

    // ---------------------------------------------------------------- helpers

4329

4330

    fn lr(x: f32, y: f32, w: f32, h: f32) -> LogicalRect {

4331

        LogicalRect {

4332

            origin: LogicalPosition::new(x, y),

4333

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

4334

4335

4336

    fn wlr(x: f32, y: f32, w: f32, h: f32) -> WindowLogicalRect {

4337

        lr(x, y, w, h).into()

4338

4339

    fn dlist(items: Vec<DisplayListItem>) -> DisplayList {

4340

        DisplayList {

4341

            items,

4342

            ..Default::default()

4343

4344

4345

    fn rect_item(x: f32, y: f32, w: f32, h: f32, color: ColorU) -> DisplayListItem {

4346

        DisplayListItem::Rect {

4347

            bounds: wlr(x, y, w, h),

4348

            color,

4349

            border_radius: BorderRadius::default(),

4350

4351

4352

    fn opaque_rect(x: f32, y: f32, w: f32, h: f32) -> DisplayListItem {

4353

        rect_item(

4354

x,

4355

y,

4356

w,

4357

h,

4358

            ColorU {

4359

                r: 10,

4360

                g: 20,

4361

                b: 30,

4362

                a: 255,

4363

},

4364

4365

4366

    fn push_scroll(id: u64, x: f32, y: f32, w: f32, h: f32) -> DisplayListItem {

4367

        DisplayListItem::PushScrollFrame {

4368

            clip_bounds: wlr(x, y, w, h),

4369

            content_size: LogicalSize::new(w, h * 10.0),

4370

            scroll_id: id,

4371

4372

4373

    /// Pixmap where each pixel encodes its own coordinates (R = x, G = y), so a

4374

    /// shift can be checked as an exact translation.

4375

    fn xy_map(w: u32, h: u32) -> AzulPixmap {

4376

        let mut p = AzulPixmap::new(w, h).unwrap();

4377

        let d = p.data_mut();

4378

        for y in 0..h {

4379

            for x in 0..w {

4380

                let i = ((y * w + x) * 4) as usize;

4381

                d[i] = (x & 0xFF) as u8;

4382

                d[i + 1] = (y & 0xFF) as u8;

4383

                d[i + 2] = 0;

4384

                d[i + 3] = 255;

4385

4386

4387

4388

4389

    fn solid(w: u32, h: u32, c: [u8; 4]) -> AzulPixmap {

4390

        let mut p = AzulPixmap::new(w, h).unwrap();

4391

        p.fill(c[0], c[1], c[2], c[3]);

4392

4393

4394

    fn at(p: &AzulPixmap, x: u32, y: u32) -> [u8; 4] {

4395

        let w = p.width();

4396

        let d = p.data();

4397

        let i = ((y * w + x) * 4) as usize;

4398

        [d[i], d[i + 1], d[i + 2], d[i + 3]]

4399

4400

    fn render_deps() -> (RendererResources, GlyphCache, CpuRenderState) {

4401

4402

            RendererResources::default(),

4403

            GlyphCache::new(),

4404

            CpuRenderState::new(ScrollOffsetMap::new()),

4405

4406

4407

4408

    // ============================== CompositorState::new (constructor) =======

4409

4410

    #[test]

4411

    fn compositor_new_zero_viewport_does_not_panic() {

4412

        // AzulPixmap::new(0, 0) returns None — Layer::new must clamp to 1×1

4413

        // instead of unwrapping a None.

4414

        let c = CompositorState::new(0, 0);

4415

        assert_eq!(c.layers.len(), 1, "only the root layer exists after new()");

4416

        assert_eq!(c.root_layer, LayerId(0));

4417

        let root = c.layers.get(&c.root_layer).unwrap();

4418

        assert_eq!(

4419

            (root.pixbuf.width(), root.pixbuf.height()),

4420

            (1, 1),

4421

            "a 0×0 viewport must degrade to a 1×1 pixbuf, not an empty/absent one"

4422

);

4423

        assert_eq!(root.bounds.size.width, 0.0);

4424

        assert_eq!(root.bounds.size.height, 0.0);

4425

4426

4427

    #[test]

4428

    fn compositor_new_invariants_hold() {

4429

        let c = CompositorState::new(800, 600);

4430

        assert_eq!(c.layers.len(), 1);

4431

        assert_eq!(c.next_layer_id_peek(), 1, "root consumes id 0");

4432

        assert!(c.previous_positions.is_empty());

4433

        let root = c.layers.get(&c.root_layer).unwrap();

4434

        assert_eq!(root.id, LayerId(0));

4435

        assert_eq!(root.bounds.size.width, 800.0);

4436

        assert_eq!(root.bounds.size.height, 600.0);

4437

        assert_eq!((root.pixbuf.width(), root.pixbuf.height()), (800, 600));

4438

        assert_eq!(root.pixbuf.data().len(), 800 * 600 * 4);

4439

        assert_eq!(

4440

            at(&root.pixbuf, 0, 0),

4441

            [255, 255, 255, 255],

4442

            "root starts opaque white"

4443

);

4444

        assert_eq!(root.opacity, 1.0);

4445

        assert!(root.children.is_empty());

4446

        assert!(root.damage.is_empty());

4447

4448

4449

    // ============================== alloc_layer_id / next_layer_id_peek ======

4450

4451

    #[test]

4452

    fn alloc_layer_id_is_unique_and_monotonic() {

4453

        let mut c = CompositorState::new(4, 4);

4454

        let ids: Vec<LayerId> = (0..1000).map(|_| c.alloc_layer_id()).collect();

4455

        for (i, id) in ids.iter().enumerate() {

4456

            assert_eq!(*id, LayerId(i as u64 + 1), "ids must be dense + monotonic");

4457

4458

        assert_eq!(c.next_layer_id_peek(), 1001);

4459

4460

4461

    #[test]

4462

    fn next_layer_id_peek_is_side_effect_free() {

4463

        let mut c = CompositorState::new(4, 4);

4464

        let before = c.next_layer_id_peek();

4465

        assert_eq!(

4466

            before,

4467

            c.next_layer_id_peek(),

4468

            "peek must not mutate the counter"

4469

);

4470

        let _ = c.alloc_layer_id();

4471

        assert_eq!(c.next_layer_id_peek(), before + 1);

4472

4473

4474

    #[test]

4475

    fn alloc_layer_id_at_u64_max_boundary() {

4476

        // The last id that can be handed out without overflowing the counter.

4477

        let mut c = CompositorState::new(4, 4);

4478

        c.next_layer_id = u64::MAX - 1;

4479

        assert_eq!(c.alloc_layer_id(), LayerId(u64::MAX - 1));

4480

        assert_eq!(c.next_layer_id_peek(), u64::MAX);

4481

4482

4483

    // ============================== Layer::new (constructor) =================

4484

4485

    #[test]

4486

    fn layer_new_zero_pixels_clamps_to_1x1_and_sets_defaults() {

4487

        let l = Layer::new(LayerId(9), lr(1.0, 2.0, 3.0, 4.0), 0, 0);

4488

        assert_eq!(l.id, LayerId(9));

4489

        assert_eq!((l.pixbuf.width(), l.pixbuf.height()), (1, 1));

4490

        assert_eq!(l.bounds.origin.x, 1.0);

4491

        assert_eq!(l.bounds.size.height, 4.0);

4492

        assert_eq!(l.opacity, 1.0);

4493

        assert_eq!(l.scroll_offset, (0.0, 0.0));

4494

        assert_eq!(l.display_list_range, (0, 0));

4495

        assert!(l.damage.is_empty());

4496

        assert!(l.children.is_empty());

4497

        assert!(l.filters.is_empty());

4498

        assert!(!l.is_backdrop_filter);

4499

        assert!(l.scroll_id.is_none());

4500

        assert!(l.composite_dirty);

4501

        assert!(l.transform.is_identity(IDENTITY_EPSILON_F64));

4502

4503

4504

    #[test]

4505

    fn layer_new_with_nan_bounds_does_not_panic() {

4506

        let nan_bounds = lr(f32::NAN, f32::NAN, f32::NAN, f32::NAN);

4507

        let l = Layer::new(LayerId(1), nan_bounds, 2, 3);

4508

        assert_eq!((l.pixbuf.width(), l.pixbuf.height()), (2, 3));

4509

        assert!(l.bounds.size.width.is_nan(), "bounds are stored verbatim");

4510

4511

4512

    // ============================== find_matching_pop =======================

4513

4514

    #[test]

4515

    fn find_matching_pop_on_empty_items_returns_len() {

4516

        let items: Vec<DisplayListItem> = Vec::new();

4517

        assert_eq!(find_matching_pop(&items, 0, MatchKind::ScrollFrame), 0);

4518

4519

4520

    #[test]

4521

    fn find_matching_pop_start_past_end_returns_len() {

4522

        // `skip(start + 1)` past the end must yield an empty iterator, not panic.

4523

        let items = vec![

4524

            push_scroll(1, 0.0, 0.0, 10.0, 10.0),

4525

            DisplayListItem::PopScrollFrame,

4526

];

4527

        assert_eq!(find_matching_pop(&items, 10, MatchKind::ScrollFrame), 2);

4528

        assert_eq!(find_matching_pop(&items, 1_000_000, MatchKind::Opacity), 2);

4529

4530

4531

    #[test]

4532

    fn find_matching_pop_unmatched_push_returns_len() {

4533

        let items = vec![

4534

            push_scroll(1, 0.0, 0.0, 10.0, 10.0),

4535

            opaque_rect(0.0, 0.0, 5.0, 5.0),

4536

];

4537

        assert_eq!(

4538

            find_matching_pop(&items, 0, MatchKind::ScrollFrame),

4539

2,

4540

            "a Push with no Pop must clamp to items.len()"

4541

);

4542

4543

4544

    #[test]

4545

    fn find_matching_pop_respects_nesting() {

4546

        let items = vec![

4547

            push_scroll(1, 0.0, 0.0, 10.0, 10.0),

4548

            push_scroll(2, 0.0, 0.0, 5.0, 5.0),

4549

            DisplayListItem::PopScrollFrame,

4550

            DisplayListItem::PopScrollFrame,

4551

];

4552

        assert_eq!(

4553

            find_matching_pop(&items, 0, MatchKind::ScrollFrame),

4554

3,

4555

            "outer pop"

4556

);

4557

        assert_eq!(

4558

            find_matching_pop(&items, 1, MatchKind::ScrollFrame),

4559

2,

4560

            "inner pop"

4561

);

4562

4563

4564

    #[test]

4565

    fn find_matching_pop_ignores_other_kinds() {

4566

        let items = vec![

4567

            push_scroll(1, 0.0, 0.0, 10.0, 10.0),

4568

            DisplayListItem::PopOpacity,

4569

            DisplayListItem::PopFilter,

4570

            DisplayListItem::PopScrollFrame,

4571

];

4572

        assert_eq!(find_matching_pop(&items, 0, MatchKind::ScrollFrame), 3);

4573

4574

4575

    #[test]

4576

    fn find_matching_pop_extra_pops_do_not_underflow_depth() {

4577

        // depth is a u32: a stream of stray Pops must not wrap it below zero.

4578

        let items = vec![

4579

            DisplayListItem::PopScrollFrame,

4580

            DisplayListItem::PopScrollFrame,

4581

            DisplayListItem::PopScrollFrame,

4582

];

4583

        assert_eq!(find_matching_pop(&items, 0, MatchKind::ScrollFrame), 1);

4584

4585

4586

    // ============================== compute_exposed_rects ===================

4587

4588

    #[test]

4589

    fn compute_exposed_rects_zero_and_subpixel_delta_expose_nothing() {

4590

        let b = lr(0.0, 0.0, 200.0, 100.0);

4591

        assert!(compute_exposed_rects(&b, 0.0, 0.0).is_empty());

4592

        assert!(

4593

            compute_exposed_rects(&b, 0.49, -0.49).is_empty(),

4594

            "|d| <= 0.5 is a no-op"

4595

);

4596

4597

4598

    #[test]

4599

    fn compute_exposed_rects_nan_delta_exposes_nothing() {

4600

        let b = lr(0.0, 0.0, 200.0, 100.0);

4601

        // NaN.abs() > 0.5 is false — no strip, no panic.

4602

        assert!(compute_exposed_rects(&b, f32::NAN, f32::NAN).is_empty());

4603

4604

4605

    #[test]

4606

    fn compute_exposed_rects_clamps_strip_to_bounds() {

4607

        let b = lr(0.0, 0.0, 200.0, 100.0);

4608

        let r = compute_exposed_rects(&b, 0.0, 1000.0);

4609

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

4610

        assert_eq!(

4611

            r[0].size.height, 100.0,

4612

            "strip cannot exceed the frame height"

4613

);

4614

        assert_eq!(r[0].size.width, 200.0);

4615

4616

4617

    #[test]

4618

    fn compute_exposed_rects_infinite_delta_saturates_to_bounds() {

4619

        let b = lr(0.0, 0.0, 200.0, 100.0);

4620

        let pos = compute_exposed_rects(&b, 0.0, f32::INFINITY);

4621

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

4622

        assert_eq!(

4623

            pos[0].size.height, 100.0,

4624

            "+inf must clamp via min(h), not stay inf"

4625

);

4626

        assert!(pos[0].origin.y.is_finite());

4627

4628

        let neg = compute_exposed_rects(&b, 0.0, f32::NEG_INFINITY);

4629

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

4630

        assert_eq!(neg[0].size.height, 100.0);

4631

        assert!(!neg[0].size.height.is_nan());

4632

4633

4634

    #[test]

4635

    fn compute_exposed_rects_diagonal_yields_two_strips() {

4636

        let b = lr(0.0, 0.0, 200.0, 100.0);

4637

        let r = compute_exposed_rects(&b, -10.0, 10.0);

4638

        assert_eq!(

4639

            r.len(),

4640

2,

4641

            "diagonal scroll = vertical strip + horizontal strip"

4642

);

4643

        assert!(r.iter().any(|s| s.size.width == 200.0), "full-width strip");

4644

        assert!(

4645

            r.iter().any(|s| s.size.height == 100.0),

4646

            "full-height strip"

4647

);

4648

4649

4650

    // ============================== scroll_shift_region =====================

4651

4652

    #[test]

4653

    fn scroll_shift_zero_dpi_is_a_noop() {

4654

        let mut p = xy_map(64, 64);

4655

        let strips = scroll_shift_region(

4656

            &mut p,

4657

            &lr(0.0, 0.0, 64.0, 64.0),

4658

            (0.0, 30.0),

4659

            (0.0, 30.0),

4660

            0.0,

4661

);

4662

        assert!(

4663

            strips.is_empty(),

4664

            "dpi 0 → 0 physical px moved → nothing exposed"

4665

);

4666

        assert_eq!(at(&p, 10, 20), [10, 20, 0, 255], "buffer must be untouched");

4667

4668

4669

    #[test]

4670

    fn scroll_shift_nan_dpi_is_a_noop() {

4671

        let mut p = xy_map(64, 64);

4672

        let strips = scroll_shift_region(

4673

            &mut p,

4674

            &lr(0.0, 0.0, 64.0, 64.0),

4675

            (0.0, 30.0),

4676

            (0.0, 30.0),

4677

            f32::NAN,

4678

);

4679

        assert!(

4680

            strips.is_empty(),

4681

            "NaN casts to 0 px — no move, no exposure"

4682

);

4683

        assert_eq!(at(&p, 10, 20), [10, 20, 0, 255]);

4684

4685

4686

    #[test]

4687

    fn scroll_shift_nan_offsets_are_a_noop() {

4688

        let mut p = xy_map(64, 64);

4689

        let strips = scroll_shift_region(

4690

            &mut p,

4691

            &lr(0.0, 0.0, 64.0, 64.0),

4692

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

4693

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

4694

            1.0,

4695

);

4696

        assert!(strips.is_empty());

4697

        assert_eq!(at(&p, 10, 20), [10, 20, 0, 255]);

4698

4699

4700

    #[test]

4701

    fn scroll_shift_negative_dpi_is_a_noop() {

4702

        // A negative scale collapses the clamped clip region to zero width.

4703

        let mut p = xy_map(64, 64);

4704

        let strips = scroll_shift_region(

4705

            &mut p,

4706

            &lr(0.0, 0.0, 64.0, 64.0),

4707

            (0.0, 10.0),

4708

            (0.0, 10.0),

4709

            -1.0,

4710

);

4711

        assert!(strips.is_empty(), "negative dpi → empty region → no move");

4712

        assert_eq!(at(&p, 10, 20), [10, 20, 0, 255]);

4713

4714

4715

    #[test]

4716

    fn scroll_shift_clip_entirely_outside_pixmap_is_a_noop() {

4717

        let mut p = xy_map(64, 64);

4718

        let strips = scroll_shift_region(

4719

            &mut p,

4720

            &lr(500.0, 500.0, 10.0, 10.0),

4721

            (0.0, 10.0),

4722

            (0.0, 10.0),

4723

            1.0,

4724

);

4725

        assert!(

4726

            strips.is_empty(),

4727

            "off-screen clip clamps to an empty region"

4728

);

4729

        assert_eq!(at(&p, 63, 63), [63, 63, 0, 255]);

4730

4731

4732

    #[test]

4733

    fn scroll_shift_huge_offset_returns_whole_clip() {

4734

        let mut p = xy_map(64, 64);

4735

        let clip = lr(0.0, 0.0, 64.0, 64.0);

4736

        let strips = scroll_shift_region(&mut p, &clip, (0.0, 1.0e9), (0.0, 1.0e9), 1.0);

4737

        assert_eq!(

4738

            strips.len(),

4739

1,

4740

            "shift ≥ region → caller repaints the whole clip"

4741

);

4742

        assert_eq!(strips[0].size.width, 64.0);

4743

        assert_eq!(strips[0].size.height, 64.0);

4744

        assert_eq!(

4745

            at(&p, 10, 20),

4746

            [10, 20, 0, 255],

4747

            "memmove is skipped entirely"

4748

);

4749

4750

4751

    #[test]

4752

    fn scroll_shift_infinite_dpi_returns_whole_clip() {

4753

        let mut p = xy_map(64, 64);

4754

        let clip = lr(0.0, 0.0, 64.0, 64.0);

4755

        // inf saturates the px delta to i32::MAX → "exceeds region" branch.

4756

        let strips = scroll_shift_region(&mut p, &clip, (0.0, 10.0), (0.0, 10.0), f32::INFINITY);

4757

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

4758

        assert_eq!(strips[0].size.height, 64.0);

4759

4760

4761

    #[test]

4762

    fn scroll_shift_clip_larger_than_pixmap_keeps_strip_on_screen() {

4763

        // Regression guard for the documented "stale duplicated band": the strip

4764

        // must come from the CLAMPED region, so it always lands inside the pixmap.

4765

        let mut p = xy_map(64, 64);

4766

        let clip = lr(-100.0, -100.0, 400.0, 400.0);

4767

        let strips = scroll_shift_region(&mut p, &clip, (0.0, 10.0), (0.0, 10.0), 1.0);

4768

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

4769

        let s = &strips[0];

4770

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

4771

        assert_eq!(s.size.width, 64.0);

4772

        assert!(

4773

            s.origin.y >= 0.0 && s.origin.y + s.size.height <= 64.0,

4774

            "exposed strip must stay inside the pixmap, got {s:?}"

4775

);

4776

        assert_eq!(

4777

            at(&p, 50, 10),

4778

            [50, 20, 0, 255],

4779

            "content translated up by 10"

4780

);

4781

4782

4783

    #[test]

4784

    fn scroll_shift_rounds_absolute_offsets_not_the_delta() {

4785

        // The doc promises round(new·dpi) − round(prev·dpi): at dpi 2 a +0.25

4786

        // logical step is 0.5 physical px, which must NOT round to 1 px each frame.

4787

        let mut p = xy_map(64, 64);

4788

        let clip = lr(0.0, 0.0, 32.0, 32.0);

4789

        let strips = scroll_shift_region(&mut p, &clip, (0.0, 0.25), (0.0, 10.25), 2.0);

4790

        // round(10.25*2)=21 (round-half-away-from-zero on .5), round(10.0*2)=20 → 1px.

4791

        assert_eq!(strips.len(), 1, "a 1px move exposes exactly one strip");

4792

        assert_eq!(

4793

            at(&p, 5, 0),

4794

            [5, 1, 0, 255],

4795

            "moved up by exactly 1 physical px"

4796

);

4797

4798

4799

    // ============================== shift_*_1d / shift_diagonal_2d ==========

4800

4801

    #[test]

4802

    fn shift_vertical_1d_zero_delta_is_a_noop() {

4803

        let mut p = xy_map(8, 8);

4804

        let before = p.data().to_vec();

4805

        shift_vertical_1d(p.data_mut(), 8, 0, 0, 8, 8, 0);

4806

        assert_eq!(

4807

            p.data(),

4808

            &before[..],

4809

            "px_dy = 0 must not touch a single byte"

4810

);

4811

4812

4813

    #[test]

4814

    fn shift_vertical_1d_delta_larger_than_region_is_a_noop() {

4815

        let mut p = xy_map(8, 8);

4816

        let before = p.data().to_vec();

4817

        shift_vertical_1d(p.data_mut(), 8, 0, 0, 8, 8, 100);

4818

        assert_eq!(

4819

            p.data(),

4820

            &before[..],

4821

            "|px_dy| ≥ height → empty row range, no panic"

4822

);

4823

        shift_vertical_1d(p.data_mut(), 8, 0, 0, 8, 8, -100);

4824

        assert_eq!(p.data(), &before[..]);

4825

4826

4827

    #[test]

4828

    fn shift_vertical_1d_moves_content_up_and_down() {

4829

        let mut p = xy_map(8, 8);

4830

        shift_vertical_1d(p.data_mut(), 8, 0, 0, 8, 8, 2); // content up by 2

4831

        assert_eq!(

4832

            at(&p, 3, 0),

4833

            [3, 2, 0, 255],

4834

            "row 0 now holds original row 2"

4835

);

4836

        assert_eq!(

4837

            at(&p, 3, 5),

4838

            [3, 7, 0, 255],

4839

            "row 5 now holds original row 7"

4840

);

4841

4842

        let mut q = xy_map(8, 8);

4843

        shift_vertical_1d(q.data_mut(), 8, 0, 0, 8, 8, -3); // content down by 3

4844

        assert_eq!(

4845

            at(&q, 3, 7),

4846

            [3, 4, 0, 255],

4847

            "row 7 now holds original row 4"

4848

);

4849

        assert_eq!(

4850

            at(&q, 3, 3),

4851

            [3, 0, 0, 255],

4852

            "row 3 now holds original row 0"

4853

);

4854

4855

4856

    #[test]

4857

    fn shift_horizontal_1d_zero_delta_is_a_noop() {

4858

        let mut p = xy_map(8, 8);

4859

        let before = p.data().to_vec();

4860

        shift_horizontal_1d(p.data_mut(), 8, 0, 0, 8, 8, 0);

4861

        assert_eq!(p.data(), &before[..]);

4862

4863

4864

    #[test]

4865

    fn shift_horizontal_1d_max_valid_shift_keeps_one_column() {

4866

        // px_dx = region_w - 1 is the largest shift scroll_shift_region can pass

4867

        // through (it early-returns at >= region_w): the copy must not underflow.

4868

        let mut p = xy_map(8, 8);

4869

        shift_horizontal_1d(p.data_mut(), 8, 0, 0, 8, 8, 7);

4870

        assert_eq!(

4871

            at(&p, 0, 4),

4872

            [7, 4, 0, 255],

4873

            "col 0 now holds original col 7"

4874

);

4875

4876

        let mut q = xy_map(8, 8);

4877

        shift_horizontal_1d(q.data_mut(), 8, 0, 0, 8, 8, -7);

4878

        assert_eq!(

4879

            at(&q, 7, 4),

4880

            [0, 4, 0, 255],

4881

            "col 7 now holds original col 0"

4882

);

4883

4884

4885

    #[test]

4886

    fn shift_horizontal_1d_only_touches_the_clip_columns() {

4887

        let mut p = xy_map(8, 8);

4888

        shift_horizontal_1d(p.data_mut(), 8, 2, 1, 6, 3, 1);

4889

        // Outside the clip rows/cols: untouched.

4890

        assert_eq!(at(&p, 0, 0), [0, 0, 0, 255]);

4891

        assert_eq!(at(&p, 7, 2), [7, 2, 0, 255], "col 7 is outside cx0..cx1");

4892

        assert_eq!(at(&p, 3, 7), [3, 7, 0, 255], "row 7 is outside cy0..cy1");

4893

        // Inside: shifted left by 1.

4894

        assert_eq!(at(&p, 2, 1), [3, 1, 0, 255]);

4895

4896

4897

    #[test]

4898

    fn shift_diagonal_2d_full_width_shift_is_a_noop() {

4899

        let mut p = xy_map(8, 8);

4900

        let before = p.data().to_vec();

4901

        shift_diagonal_2d(p.data_mut(), 8, 0, 0, 8, 8, 8, 1); // span_cols == 0

4902

        assert_eq!(p.data(), &before[..], "nothing left to keep → early return");

4903

4904

4905

    #[test]

4906

    fn shift_diagonal_2d_translates_both_axes_in_one_pass() {

4907

        let mut p = xy_map(8, 8);

4908

        shift_diagonal_2d(p.data_mut(), 8, 0, 0, 8, 8, 2, 3); // content up-left

4909

        assert_eq!(at(&p, 0, 0), [2, 3, 0, 255], "(0,0) holds original (2,3)");

4910

        assert_eq!(at(&p, 5, 4), [7, 7, 0, 255], "(5,4) holds original (7,7)");

4911

4912

        let mut q = xy_map(8, 8);

4913

        shift_diagonal_2d(q.data_mut(), 8, 0, 0, 8, 8, -2, -3); // content down-right

4914

        assert_eq!(at(&q, 7, 7), [5, 4, 0, 255], "(7,7) holds original (5,4)");

4915

4916

4917

    // ============================== rect_covered_by =========================

4918

4919

    #[test]

4920

    fn rect_covered_by_empty_covers_is_false() {

4921

        assert!(!rect_covered_by(&lr(0.0, 0.0, 10.0, 10.0), &[]));

4922

4923

4924

    #[test]

4925

    fn rect_covered_by_degenerate_target_is_vacuously_covered() {

4926

        let cover = [lr(0.0, 0.0, 10.0, 10.0)];

4927

        // No sample points → the "every sample is inside" predicate holds.

4928

        assert!(

4929

            rect_covered_by(&lr(0.0, 0.0, 0.0, 0.0), &cover),

4930

            "zero-size target"

4931

);

4932

        assert!(

4933

            rect_covered_by(&lr(0.0, 0.0, -50.0, -50.0), &cover),

4934

            "negative-size target"

4935

);

4936

        assert!(

4937

            rect_covered_by(&lr(0.0, 0.0, f32::NAN, f32::NAN), &cover),

4938

            "NaN target must terminate (no infinite while-float loop) and be defined"

4939

);

4940

4941

4942

    #[test]

4943

    fn rect_covered_by_tolerates_sub_4px_gaps_but_not_wide_ones() {

4944

        let target = lr(0.0, 0.0, 100.0, 100.0);

4945

        // 1px gap at y ∈ [49, 50) — no 4px sample lands in it → still "covered".

4946

        assert!(rect_covered_by(

4947

            &target,

4948

            &[lr(0.0, 0.0, 100.0, 49.0), lr(0.0, 50.0, 100.0, 50.0)]

4949

));

4950

        // 20px gap → sampled → not covered.

4951

        assert!(!rect_covered_by(

4952

            &target,

4953

            &[lr(0.0, 0.0, 100.0, 40.0), lr(0.0, 60.0, 100.0, 40.0)]

4954

));

4955

4956

4957

    // ============================== rects_overlap_or_adjacent ===============

4958

4959

    #[test]

4960

    fn rects_touching_with_zero_gap_are_adjacent() {

4961

        let a = lr(0.0, 0.0, 10.0, 10.0);

4962

        let b = lr(10.0, 0.0, 10.0, 10.0);

4963

        assert!(

4964

            rects_overlap_or_adjacent(&a, &b, 0.0),

4965

            "shared edge counts as adjacent"

4966

);

4967

        assert!(!rects_overlap_or_adjacent(

4968

&a,

4969

            &lr(11.0, 0.0, 10.0, 10.0),

4970

0.0

4971

));

4972

4973

4974

    #[test]

4975

    fn rects_overlap_negative_gap_requires_real_overlap() {

4976

        let a = lr(0.0, 0.0, 10.0, 10.0);

4977

        let b = lr(10.0, 0.0, 10.0, 10.0);

4978

        assert!(

4979

            !rects_overlap_or_adjacent(&a, &b, -1.0),

4980

            "a negative gap must SHRINK the test, not widen it"

4981

);

4982

        assert!(rects_overlap_or_adjacent(

4983

&a,

4984

            &lr(5.0, 0.0, 10.0, 10.0),

4985

            -1.0

4986

));

4987

4988

4989

    #[test]

4990

    fn rects_overlap_nan_inputs_are_false_not_panics() {

4991

        let a = lr(0.0, 0.0, 10.0, 10.0);

4992

        let nan = lr(f32::NAN, f32::NAN, f32::NAN, f32::NAN);

4993

        assert!(

4994

            !rects_overlap_or_adjacent(&a, &nan, 0.0),

4995

            "NaN compares false everywhere"

4996

);

4997

        assert!(

4998

            !rects_overlap_or_adjacent(&a, &a, f32::NAN),

4999

            "NaN gap → false"

5000

);

5001

5002

5003

    #[test]

5004

    fn rects_overlap_infinite_gap_swallows_everything() {

5005

        let a = lr(0.0, 0.0, 1.0, 1.0);

5006

        let b = lr(1.0e9, 1.0e9, 1.0, 1.0);

5007

        assert!(rects_overlap_or_adjacent(&a, &b, f32::INFINITY));

5008

5009

5010

    // ============================== coalesce_damage_rects ===================

5011

5012

    #[test]

5013

    fn coalesce_empty_and_single_are_untouched() {

5014

        let mut v: Vec<LogicalRect> = Vec::new();

5015

        coalesce_damage_rects(&mut v);

5016

        assert!(v.is_empty());

5017

        let mut one = vec![lr(1.0, 2.0, 3.0, 4.0)];

5018

        coalesce_damage_rects(&mut one);

5019

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

5020

        assert_eq!(one[0].origin.x, 1.0);

5021

5022

5023

    #[test]

5024

    fn coalesce_merges_identical_and_chained_rects() {

5025

        let mut v = vec![lr(0.0, 0.0, 10.0, 10.0), lr(0.0, 0.0, 10.0, 10.0)];

5026

        coalesce_damage_rects(&mut v);

5027

        assert_eq!(v.len(), 1, "duplicates must collapse");

5028

5029

        let mut chain = vec![

5030

            lr(0.0, 0.0, 10.0, 10.0),

5031

            lr(5.0, 0.0, 10.0, 10.0),

5032

            lr(10.0, 0.0, 10.0, 10.0),

5033

];

5034

        coalesce_damage_rects(&mut chain);

5035

        assert_eq!(

5036

            chain.len(),

5037

1,

5038

            "an overlapping chain collapses transitively"

5039

);

5040

        assert_eq!(chain[0].size.width, 20.0);

5041

5042

5043

    #[test]

5044

    fn coalesce_keeps_distant_rects_separate() {

5045

        let mut v = vec![lr(0.0, 0.0, 10.0, 10.0), lr(500.0, 500.0, 10.0, 10.0)];

5046

        coalesce_damage_rects(&mut v);

5047

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

5048

5049

5050

    #[test]

5051

    fn coalesce_rejects_perpendicular_strip_union() {

5052

        // The documented anti-ballooning guard: a vertical + a horizontal

5053

        // scrollbar strip touch at a corner but their union is the viewport.

5054

        let mut v = vec![lr(990.0, 0.0, 10.0, 1000.0), lr(0.0, 990.0, 1000.0, 10.0)];

5055

        coalesce_damage_rects(&mut v);

5056

        assert_eq!(

5057

            v.len(),

5058

2,

5059

            "union would be 100× the painted area — must stay split"

5060

);

5061

5062

5063

    #[test]

5064

    fn coalesce_with_nan_rects_terminates() {

5065

        // NaN comparisons are always false → no merge, and the fixpoint loop

5066

        // must still terminate rather than spin.

5067

        let mut v = vec![

5068

            lr(f32::NAN, f32::NAN, f32::NAN, f32::NAN),

5069

            lr(0.0, 0.0, 10.0, 10.0),

5070

            lr(f32::NAN, 0.0, 10.0, 10.0),

5071

];

5072

        coalesce_damage_rects(&mut v);

5073

        assert_eq!(v.len(), 3);

5074

5075

5076

    // ============================== compute_resize_damage ===================

5077

5078

    #[test]

5079

    fn resize_damage_shrink_or_equal_is_empty() {

5080

        assert!(compute_resize_damage(100.0, 100.0, 100.0, 100.0).is_empty());

5081

        assert!(

5082

            compute_resize_damage(100.0, 100.0, 50.0, 50.0).is_empty(),

5083

            "grow-only"

5084

);

5085

5086

5087

    #[test]

5088

    fn resize_damage_grow_both_axes_gives_right_and_bottom_strips() {

5089

        let r = compute_resize_damage(100.0, 100.0, 200.0, 150.0);

5090

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

5091

        assert_eq!(r[0].origin.x, 100.0, "right strip starts at the old width");

5092

        assert_eq!(r[0].size.width, 100.0);

5093

        assert_eq!(r[0].size.height, 150.0, "right strip spans the NEW height");

5094

        assert_eq!(

5095

            r[1].origin.y, 100.0,

5096

            "bottom strip starts at the old height"

5097

);

5098

        assert_eq!(

5099

            r[1].size.width, 100.0,

5100

            "bottom strip is min(old, new) wide — no overdraw"

5101

);

5102

        assert_eq!(r[1].size.height, 50.0);

5103

5104

5105

    #[test]

5106

    fn resize_damage_zero_and_nan_are_defined() {

5107

        assert!(compute_resize_damage(0.0, 0.0, 0.0, 0.0).is_empty());

5108

        assert_eq!(compute_resize_damage(0.0, 0.0, 10.0, 10.0).len(), 2);

5109

        assert!(

5110

            compute_resize_damage(f32::NAN, f32::NAN, f32::NAN, f32::NAN).is_empty(),

5111

            "NaN > NaN is false → no damage, no panic"

5112

);

5113

        assert!(compute_resize_damage(f32::NAN, f32::NAN, 10.0, 10.0).is_empty());

5114

5115

5116

    #[test]

5117

    fn resize_damage_infinite_new_size_does_not_panic() {

5118

        let r = compute_resize_damage(0.0, 0.0, f32::INFINITY, f32::INFINITY);

5119

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

5120

        assert!(

5121

            r[0].size.width.is_infinite(),

5122

            "inf propagates, but nothing panics"

5123

);

5124

5125

5126

    // ============================== compare_region ==========================

5127

5128

    #[test]

5129

    fn compare_region_identical_pixmaps_report_zero() {

5130

        let a = solid(4, 4, [1, 2, 3, 255]);

5131

        let b = solid(4, 4, [1, 2, 3, 255]);

5132

        assert_eq!(compare_region(&a, &b, 0, 0, 4, 4, 0), 0);

5133

5134

5135

    #[test]

5136

    fn compare_region_threshold_255_never_counts_a_pixel() {

5137

        // Max per-channel distance is 255, and the test is strictly `>`.

5138

        let a = solid(4, 4, [0, 0, 0, 255]);

5139

        let b = solid(4, 4, [255, 255, 255, 255]);

5140

        assert_eq!(

5141

            compare_region(&a, &b, 0, 0, 4, 4, 255),

5142

0,

5143

            "saturated threshold = blind"

5144

);

5145

        assert_eq!(

5146

            compare_region(&a, &b, 0, 0, 4, 4, 254),

5147

16,

5148

            "one below → every pixel"

5149

);

5150

        assert_eq!(compare_region(&a, &b, 0, 0, 4, 4, 0), 16);

5151

5152

5153

    #[test]

5154

    fn compare_region_ignores_the_alpha_channel() {

5155

        let a = solid(4, 4, [9, 9, 9, 255]);

5156

        let b = solid(4, 4, [9, 9, 9, 0]);

5157

        assert_eq!(

5158

            compare_region(&a, &b, 0, 0, 4, 4, 0),

5159

0,

5160

            "only RGB is compared"

5161

);

5162

5163

5164

    #[test]

5165

    fn compare_region_clamps_oversized_and_empty_regions() {

5166

        let a = solid(4, 4, [0, 0, 0, 255]);

5167

        let b = solid(4, 4, [255, 255, 255, 255]);

5168

        assert_eq!(

5169

            compare_region(&a, &b, 0, 0, u32::MAX, u32::MAX, 0),

5170

16,

5171

            "w/h are clamped to the pixmaps — no OOB, no overflow"

5172

);

5173

        assert_eq!(compare_region(&a, &b, 0, 0, 0, 0, 0), 0, "empty region");

5174

        assert_eq!(

5175

            compare_region(&a, &b, u32::MAX, u32::MAX, 0, 0, 0),

5176

0,

5177

            "origin at u32::MAX with a zero extent must not overflow x + w"

5178

);

5179

5180

5181

    #[test]

5182

    fn compare_region_with_mismatched_pixmap_sizes_uses_the_overlap() {

5183

        let a = solid(4, 4, [0, 0, 0, 255]);

5184

        let b = solid(2, 2, [255, 255, 255, 255]);

5185

        assert_eq!(

5186

            compare_region(&a, &b, 0, 0, 4, 4, 0),

5187

4,

5188

            "iteration clamps to min(a, b) — the 2×2 overlap"

5189

);

5190

5191

5192

    // ============================== opaque_fill_rect ========================

5193

5194

    #[test]

5195

    fn opaque_fill_rect_accepts_only_opaque_square_rects() {

5196

        assert!(opaque_fill_rect(&opaque_rect(1.0, 2.0, 3.0, 4.0)).is_some());

5197

        assert!(

5198

            opaque_fill_rect(&rect_item(

5199

                0.0,

5200

                0.0,

5201

                1.0,

5202

                1.0,

5203

                ColorU {

5204

                    r: 0,

5205

                    g: 0,

5206

                    b: 0,

5207

                    a: 254

5208

5209

))

5210

            .is_none(),

5211

            "a = 254 is not fully opaque"

5212

);

5213

        let rounded = DisplayListItem::Rect {

5214

            bounds: wlr(0.0, 0.0, 10.0, 10.0),

5215

            color: ColorU {

5216

                r: 0,

5217

                g: 0,

5218

                b: 0,

5219

                a: 255,

5220

},

5221

            border_radius: BorderRadius {

5222

                top_left: 0.1,

5223

                top_right: 0.0,

5224

                bottom_left: 0.0,

5225

                bottom_right: 0.0,

5226

},

5227

};

5228

        assert!(

5229

            opaque_fill_rect(&rounded).is_none(),

5230

            "any corner radius disqualifies"

5231

);

5232

        assert!(opaque_fill_rect(&DisplayListItem::PopScrollFrame).is_none());

5233

        let b = opaque_fill_rect(&opaque_rect(1.0, 2.0, 3.0, 4.0)).unwrap();

5234

        assert_eq!((b.origin.x, b.size.height), (1.0, 4.0));

5235

5236

5237

    // ============================== scroll_fast_path_eligible ===============

5238

5239

    #[test]

5240

    fn fast_path_eligible_when_no_such_frame() {

5241

        assert!(scroll_fast_path_eligible(

5242

            &dlist(vec![]),

5243

3,

5244

            &lr(0.0, 0.0, 10.0, 10.0),

5245

            (0.0, 0.0),

5246

            (0.0, 0.0)

5247

));

5248

5249

5250

    #[test]

5251

    fn fast_path_ineligible_for_a_nested_frame() {

5252

        // Inner clip_bounds are in the OUTER frame's content space → memmove

5253

        // would shift the wrong region.

5254

        let list = dlist(vec![

5255

            push_scroll(1, 0.0, 0.0, 100.0, 100.0),

5256

            push_scroll(2, 0.0, 0.0, 50.0, 50.0),

5257

            opaque_rect(0.0, 0.0, 50.0, 500.0),

5258

            DisplayListItem::PopScrollFrame,

5259

            DisplayListItem::PopScrollFrame,

5260

]);

5261

        assert!(

5262

            !scroll_fast_path_eligible(&list, 2, &lr(0.0, 0.0, 50.0, 50.0), (0.0, 0.0), (0.0, 0.0)),

5263

            "a nested frame must fall back to a full repaint"

5264

);

5265

        assert!(

5266

            scroll_fast_path_eligible(

5267

                &list,

5268

1,

5269

                &lr(0.0, 0.0, 100.0, 100.0),

5270

                (0.0, 0.0),

5271

                (0.0, 0.0)

5272

),

5273

            "the outer frame is still eligible (nothing painted behind it)"

5274

);

5275

5276

5277

    #[test]

5278

    fn fast_path_zero_area_clip_does_not_divide_by_zero() {

5279

        let list = dlist(vec![

5280

            push_scroll(1, 0.0, 0.0, 0.0, 0.0),

5281

            opaque_rect(0.0, 0.0, 10.0, 10.0),

5282

            DisplayListItem::PopScrollFrame,

5283

]);

5284

        // clip_area is max(1.0)-guarded; must return a bool, not panic.

5285

        assert!(scroll_fast_path_eligible(

5286

            &list,

5287

1,

5288

            &lr(0.0, 0.0, 0.0, 0.0),

5289

            (0.0, 0.0),

5290

            (0.0, 0.0)

5291

));

5292

5293

5294

    #[test]

5295

    fn fast_path_checks_coverage_at_both_offsets() {

5296

        // Content covers the clip only while the frame is at offset 0; scrolled

5297

        // by 60 it uncovers the bottom half, exposing a partial backdrop.

5298

        let list = dlist(vec![

5299

            opaque_rect(0.0, 0.0, 100.0, 40.0), // partial backdrop (≥10% of clip)

5300

            push_scroll(7, 0.0, 0.0, 100.0, 100.0),

5301

            opaque_rect(0.0, 0.0, 100.0, 100.0), // covers the clip at offset 0 only

5302

            DisplayListItem::PopScrollFrame,

5303

]);

5304

        let clip = lr(0.0, 0.0, 100.0, 100.0);

5305

        assert!(scroll_fast_path_eligible(

5306

            &list,

5307

7,

5308

            &clip,

5309

            (0.0, 0.0),

5310

            (0.0, 0.0)

5311

));

5312

        assert!(

5313

            !scroll_fast_path_eligible(&list, 7, &clip, (0.0, 60.0), (0.0, 0.0)),

5314

            "coverage must hold at the NEW offset too, not just the old one"

5315

);

5316

        assert!(

5317

            !scroll_fast_path_eligible(&list, 7, &clip, (0.0, 0.0), (0.0, 60.0)),

5318

            "…and at the OLD offset, where the dragged pixels were rendered"

5319

);

5320

5321

5322

    // ============================== overlay_rects_after_frame ================

5323

5324

    #[test]

5325

    fn overlay_rects_empty_without_a_matching_frame() {

5326

        let list = dlist(vec![opaque_rect(0.0, 0.0, 10.0, 10.0)]);

5327

        assert!(overlay_rects_after_frame(&list, 99, &lr(0.0, 0.0, 10.0, 10.0)).is_empty());

5328

5329

5330

    #[test]

5331

    fn overlay_rects_require_strict_overlap_and_are_clipped() {

5332

        let clip = lr(0.0, 0.0, 100.0, 100.0);

5333

        let list = dlist(vec![

5334

            push_scroll(1, 0.0, 0.0, 100.0, 100.0),

5335

            opaque_rect(0.0, 0.0, 100.0, 500.0), // inside the frame — not an overlay

5336

            DisplayListItem::PopScrollFrame,

5337

            opaque_rect(100.0, 0.0, 10.0, 10.0), // merely TOUCHES the clip edge

5338

            opaque_rect(90.0, 90.0, 40.0, 40.0), // genuinely overlaps

5339

            DisplayListItem::PushClip {

5340

                // state-management → skipped

5341

                bounds: wlr(0.0, 0.0, 100.0, 100.0),

5342

                border_radius: BorderRadius::default(),

5343

},

5344

]);

5345

        let r = overlay_rects_after_frame(&list, 1, &clip);

5346

        assert_eq!(r.len(), 1, "only the strictly-overlapping item, got {r:?}");

5347

        assert_eq!(r[0].origin.x, 90.0);

5348

        assert_eq!(

5349

            r[0].size.width, 10.0,

5350

            "intersection is clipped to the frame"

5351

);

5352

        assert_eq!(r[0].size.height, 10.0);

5353

5354

5355

    // ============================== gpu_value_damage =========================

5356

5357

    fn translate(tx: f32, ty: f32) -> ComputedTransform3D {

5358

        ComputedTransform3D {

5359

            m: [

5360

                [1.0, 0.0, 0.0, 0.0],

5361

                [0.0, 1.0, 0.0, 0.0],

5362

                [0.0, 0.0, 1.0, 0.0],

5363

                [tx, ty, 0.0, 1.0],

5364

],

5365

5366

5367

    fn ref_frame(key: usize) -> DisplayListItem {

5368

        DisplayListItem::PushReferenceFrame {

5369

            transform_key: TransformKey { id: key },

5370

            initial_transform: ComputedTransform3D::IDENTITY,

5371

            bounds: wlr(0.0, 0.0, 50.0, 50.0),

5372

5373

5374

5375

    #[test]

5376

    fn gpu_value_damage_unchanged_maps_report_nothing() {

5377

        let list = dlist(vec![ref_frame(3), DisplayListItem::PopReferenceFrame]);

5378

        let mut t: HashMap<usize, ComputedTransform3D> = HashMap::new();

5379

        t.insert(3, translate(1.0, 1.0));

5380

        let mut o: HashMap<usize, f32> = HashMap::new();

5381

        o.insert(4, 0.5);

5382

        let d = gpu_value_damage(&list, &t, &o, &t.clone(), &o.clone());

5383

        assert!(d.rects.is_empty());

5384

        assert!(!d.needs_full);

5385

5386

        let empty_t: HashMap<usize, ComputedTransform3D> = HashMap::new();

5387

        let empty_o: HashMap<usize, f32> = HashMap::new();

5388

        let d2 = gpu_value_damage(&list, &empty_t, &empty_o, &empty_t, &empty_o);

5389

        assert!(

5390

            d2.rects.is_empty() && !d2.needs_full,

5391

            "empty maps → no damage"

5392

);

5393

5394

5395

    #[test]

5396

    fn gpu_value_damage_changed_transform_on_a_reference_frame_damages_both_positions() {

5397

        let list = dlist(vec![ref_frame(3), DisplayListItem::PopReferenceFrame]);

5398

        let mut old_t: HashMap<usize, ComputedTransform3D> = HashMap::new();

5399

        old_t.insert(3, ComputedTransform3D::IDENTITY);

5400

        let mut new_t: HashMap<usize, ComputedTransform3D> = HashMap::new();

5401

        new_t.insert(3, translate(20.0, 0.0));

5402

        let o: HashMap<usize, f32> = HashMap::new();

5403

        let d = gpu_value_damage(&list, &old_t, &o, &new_t, &o);

5404

        // The content extent IS knowable (the frame's items + its own

5405

        // bounds), so a moved frame damages its content at the OLD and the

5406

        // NEW matrix — the previous blanket needs_full made every spring

5407

        // tick a full-frame repaint.

5408

        assert!(!d.needs_full, "affine moves must not full-repaint");

5409

        assert_eq!(d.rects.len(), 2, "old position + new position");

5410

        let dx = (d.rects[1].origin.x - d.rects[0].origin.x).abs();

5411

        assert!(

5412

            (dx - 20.0).abs() < 0.01,

5413

            "the two rects are 20px apart, got {dx}"

5414

);

5415

5416

5417

    #[test]

5418

    fn gpu_value_damage_removed_key_counts_as_changed() {

5419

        let list = dlist(vec![ref_frame(3), DisplayListItem::PopReferenceFrame]);

5420

        let mut old_t: HashMap<usize, ComputedTransform3D> = HashMap::new();

5421

        old_t.insert(3, translate(5.0, 5.0));

5422

        let new_t: HashMap<usize, ComputedTransform3D> = HashMap::new();

5423

        let o: HashMap<usize, f32> = HashMap::new();

5424

        let d = gpu_value_damage(&list, &old_t, &o, &new_t, &o);

5425

        assert!(

5426

            !d.rects.is_empty() || d.needs_full,

5427

            "a key present in old but absent in new is a change (the frame settles to identity, \

5428

             damaging its old offset position)"

5429

);

5430

        assert!(

5431

            !d.needs_full,

5432

            "the settle is affine — rect damage, not full"

5433

);

5434

5435

5436

    #[test]

5437

    fn gpu_value_damage_ignores_keys_bound_to_nothing() {

5438

        let list = dlist(vec![opaque_rect(0.0, 0.0, 10.0, 10.0)]);

5439

        let t: HashMap<usize, ComputedTransform3D> = HashMap::new();

5440

        let mut new_t: HashMap<usize, ComputedTransform3D> = HashMap::new();

5441

        new_t.insert(77, translate(1.0, 0.0));

5442

        let old_o: HashMap<usize, f32> = HashMap::new();

5443

        let mut new_o: HashMap<usize, f32> = HashMap::new();

5444

        new_o.insert(88, 0.25);

5445

        let d = gpu_value_damage(&list, &t, &old_o, &new_t, &new_o);

5446

        assert!(

5447

            d.rects.is_empty() && !d.needs_full,

5448

            "a key bound to no item cannot damage"

5449

);

5450

5451

5452

    #[test]

5453

    fn gpu_value_damage_nan_opacity_is_change_but_still_unbound() {

5454

        let list = dlist(vec![opaque_rect(0.0, 0.0, 10.0, 10.0)]);

5455

        let t: HashMap<usize, ComputedTransform3D> = HashMap::new();

5456

        let mut o: HashMap<usize, f32> = HashMap::new();

5457

        o.insert(1, f32::NAN);

5458

        // NaN != NaN → the key reads as "changed"; nothing binds it, so no damage.

5459

        let d = gpu_value_damage(&list, &t, &o.clone(), &t, &o);

5460

        assert!(d.rects.is_empty() && !d.needs_full);

5461

5462

5463

    // ============================== display list diffing =====================

5464

5465

    #[test]

5466

    fn display_lists_visually_equal_basics() {

5467

        let a = dlist(vec![opaque_rect(0.0, 0.0, 10.0, 10.0)]);

5468

        let b = dlist(vec![opaque_rect(0.0, 0.0, 10.0, 10.0)]);

5469

        assert!(

5470

            display_lists_visually_equal(&dlist(vec![]), &dlist(vec![])),

5471

            "empty == empty"

5472

);

5473

        assert!(display_lists_visually_equal(&a, &b));

5474

        assert!(

5475

            !display_lists_visually_equal(&a, &dlist(vec![])),

5476

            "length differs"

5477

);

5478

        let c = dlist(vec![rect_item(

5479

            0.0,

5480

            0.0,

5481

            10.0,

5482

            10.0,

5483

            ColorU {

5484

                r: 9,

5485

                g: 9,

5486

                b: 9,

5487

                a: 255,

5488

},

5489

        )]);

5490

        assert!(!display_lists_visually_equal(&a, &c), "colour differs");

5491

        let d = dlist(vec![DisplayListItem::PopClip]);

5492

        assert!(

5493

            !display_lists_visually_equal(&a, &d),

5494

            "discriminant differs"

5495

);

5496

5497

5498

    /// DETECTOR for a bug class, not for one widget.

5499

///

5500

    /// Reported against the slider: dragging it left a trail of blue thumbs on

5501

    /// the grey track, each the thumb's previous position, never repainted. The

5502

    /// slider is not special — anything that repositions a child by a layout

5503

    /// property is exposed the same way. The diff can notice an item at its NEW

5504

    /// rect and forget the OLD one, and what you see is stale paint that reads

5505

    /// as a rendering glitch rather than a damage bug.

5506

///

5507

    /// The invariant, stated once so every future mover inherits it:

5508

///

5509

    ///   when an item moves, the damage must cover BOTH the rect it left and

5510

    ///   the rect it arrived at.

5511

///

5512

    /// Covering only the new rect is the trail. Covering only the old one is an

5513

    /// element that never appears. Same defect, two symptoms, one assertion.

5514

    #[test]

5515

    fn a_moved_item_damages_the_pixels_it_vacated() {

5516

        let off = ScrollOffsetMap::new();

5517

5518

        // Sweep a range of distances: a mover that overlaps its old position

5519

        // can be covered by a single sloppy rect and hide the bug, so include

5520

        // clearly disjoint moves too.

5521

        for delta in [4.0_f32, 16.0, 64.0, 150.0] {

5522

            let a = dlist(vec![opaque_rect(0.0, 0.0, 16.0, 16.0)]);

5523

            let b = dlist(vec![opaque_rect(delta, 0.0, 16.0, 16.0)]);

5524

            let d = compute_display_list_damage(&a, &b, &off, &off)

5525

                .expect("a pure move is not a structural change");

5526

5527

            let covers = |x: f32, y: f32, w: f32, h: f32| {

5528

                let (x1, y1) = (x + w, y + h);

5529

                d.iter().any(|r| {

5530

                    r.origin.x <= x + 0.01

5531

                        && r.origin.y <= y + 0.01

5532

                        && r.origin.x + r.size.width + 0.01 >= x1

5533

                        && r.origin.y + r.size.height + 0.01 >= y1

5534

})

5535

};

5536

5537

            assert!(

5538

                covers(delta, 0.0, 16.0, 16.0),

5539

                "delta={delta}: damage misses the NEW rect, so the item would never appear there. \

5540

                 damage={d:?}"

5541

);

5542

            assert!(

5543

                covers(0.0, 0.0, 16.0, 16.0),

5544

                "delta={delta}: damage misses the pixels the item VACATED. The old paint stays on \

5545

                 screen — this is the slider's trail of blue thumbs on the grey track, and it is \

5546

                 a property of the damage diff, not of the slider. damage={d:?}"

5547

);

5548

5549

5550

5551

    #[test]

5552

    fn damage_diff_windows_a_structural_change() {

5553

        // A structural change used to bail to a FULL repaint; it now damages

5554

        // the changed window (here: the removed rect's own area).

5555

        let off = ScrollOffsetMap::new();

5556

        let a = dlist(vec![opaque_rect(0.0, 0.0, 10.0, 10.0)]);

5557

        let d = compute_display_list_damage(&a, &dlist(vec![]), &off, &off)

5558

            .expect("a removed item damages its area, not the full frame");

5559

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

5560

        assert!((d[0].size.width - 10.0).abs() < 0.5 && (d[0].size.height - 10.0).abs() < 0.5);

5561

        let b = dlist(vec![DisplayListItem::PopClip]);

5562

        let d = compute_display_list_damage(&a, &b, &off, &off)

5563

            .expect("a replaced item damages its area");

5564

        assert_eq!(

5565

            d.len(),

5566

1,

5567

            "the boundless PopClip contributes no rect of its own"

5568

);

5569

        // A change with NO bounds-carrying item anywhere in the window stays

5570

        // a full repaint — conservative, never "no damage".

5571

        let c = dlist(vec![DisplayListItem::PopClip]);

5572

        let e = dlist(vec![DisplayListItem::PopScrollFrame]);

5573

        assert!(compute_display_list_damage(&c, &e, &off, &off).is_none());

5574

5575

5576

    #[test]

5577

    fn damage_diff_of_identical_lists_is_empty() {

5578

        let off = ScrollOffsetMap::new();

5579

        let a = dlist(vec![opaque_rect(0.0, 0.0, 10.0, 10.0)]);

5580

        let b = dlist(vec![opaque_rect(0.0, 0.0, 10.0, 10.0)]);

5581

        let d = compute_display_list_damage(&a, &b, &off, &off).expect("no structural change");

5582

        assert!(d.is_empty(), "identical frames damage nothing");

5583

        let e = compute_display_list_damage(&dlist(vec![]), &dlist(vec![]), &off, &off);

5584

        assert_eq!(

5585

            e.map(|v| v.len()),

5586

            Some(0),

5587

            "two empty lists are comparable"

5588

);

5589

5590

5591

    #[test]

5592

    fn damage_diff_covers_a_colour_change() {

5593

        let off = ScrollOffsetMap::new();

5594

        let a = dlist(vec![opaque_rect(10.0, 10.0, 20.0, 20.0)]);

5595

        let b = dlist(vec![rect_item(

5596

            10.0,

5597

            10.0,

5598

            20.0,

5599

            20.0,

5600

            ColorU {

5601

                r: 1,

5602

                g: 1,

5603

                b: 1,

5604

                a: 255,

5605

},

5606

        )]);

5607

        let d = compute_display_list_damage(&a, &b, &off, &off).unwrap();

5608

        assert_eq!(d.len(), 1, "old + new bounds coincide → one coalesced rect");

5609

        assert_eq!(d[0].origin.x, 10.0);

5610

        assert_eq!(d[0].size.width, 20.0);

5611

5612

5613

    #[test]

5614

    fn damage_diff_projects_scroll_offsets_into_viewport_space() {

5615

        // The item lives at content y = 100 inside frame 1. Old offset 0, new

5616

        // offset 50 → its pixels were at y=100 and will be at y=50.

5617

        let mut old_off = ScrollOffsetMap::new();

5618

        old_off.insert(1, (0.0, 0.0));

5619

        let mut new_off = ScrollOffsetMap::new();

5620

        new_off.insert(1, (0.0, 50.0));

5621

        let old = dlist(vec![

5622

            push_scroll(1, 0.0, 0.0, 100.0, 100.0),

5623

            opaque_rect(0.0, 100.0, 10.0, 10.0),

5624

            DisplayListItem::PopScrollFrame,

5625

]);

5626

        let new = dlist(vec![

5627

            push_scroll(1, 0.0, 0.0, 100.0, 100.0),

5628

            rect_item(

5629

                0.0,

5630

                100.0,

5631

                10.0,

5632

                10.0,

5633

                ColorU {

5634

                    r: 7,

5635

                    g: 7,

5636

                    b: 7,

5637

                    a: 255,

5638

},

5639

),

5640

            DisplayListItem::PopScrollFrame,

5641

]);

5642

        let d = compute_display_list_damage(&old, &new, &old_off, &new_off).unwrap();

5643

        assert_eq!(

5644

            d.len(),

5645

2,

5646

            "old and new positions are 40px apart → no merge, got {d:?}"

5647

);

5648

        let ys: Vec<f32> = d.iter().map(|r| r.origin.y).collect();

5649

        assert!(

5650

            ys.contains(&100.0),

5651

            "old pixels at y=100 (offset 0), got {ys:?}"

5652

);

5653

        assert!(

5654

            ys.contains(&50.0),

5655

            "new pixels at y=50 (offset 50), got {ys:?}"

5656

);

5657

5658

5659

    // ============================== compute_virtual_view_damage ==============

5660

5661

    #[test]

5662

    fn virtual_view_damage_without_virtual_views_is_empty() {

5663

        let parent = dlist(vec![opaque_rect(0.0, 0.0, 10.0, 10.0)]);

5664

        let cur: BTreeMap<DomId, Arc<DisplayList>> = BTreeMap::new();

5665

        let prev: BTreeMap<DomId, Arc<DisplayList>> = BTreeMap::new();

5666

        assert!(compute_virtual_view_damage(&parent, &cur, &prev).is_empty());

5667

5668

5669

    #[test]

5670

    fn virtual_view_damage_tracks_child_dom_changes() {

5671

        let dom = DomId { inner: 1 };

5672

        let parent = dlist(vec![DisplayListItem::VirtualView {

5673

            child_dom_id: dom,

5674

            bounds: wlr(5.0, 6.0, 40.0, 30.0),

5675

            clip_rect: wlr(5.0, 6.0, 40.0, 30.0),

5676

            content_offset: Default::default(),

5677

        }]);

5678

        let shared = Arc::new(dlist(vec![opaque_rect(0.0, 0.0, 10.0, 10.0)]));

5679

        let equal_but_distinct = Arc::new(dlist(vec![opaque_rect(0.0, 0.0, 10.0, 10.0)]));

5680

        let different = Arc::new(dlist(vec![opaque_rect(0.0, 0.0, 99.0, 99.0)]));

5681

5682

        let mut cur: BTreeMap<DomId, Arc<DisplayList>> = BTreeMap::new();

5683

        let mut prev: BTreeMap<DomId, Arc<DisplayList>> = BTreeMap::new();

5684

5685

        // Same Arc → cheap pointer fast-path → no damage.

5686

        cur.insert(dom, Arc::clone(&shared));

5687

        prev.insert(dom, Arc::clone(&shared));

5688

        assert!(compute_virtual_view_damage(&parent, &cur, &prev).is_empty());

5689

5690

        // Distinct Arcs, identical content → still no damage.

5691

        cur.insert(dom, Arc::clone(&equal_but_distinct));

5692

        assert!(compute_virtual_view_damage(&parent, &cur, &prev).is_empty());

5693

5694

        // Content actually changed → damage the VirtualView's on-screen bounds.

5695

        cur.insert(dom, Arc::clone(&different));

5696

        let d = compute_virtual_view_damage(&parent, &cur, &prev);

5697

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

5698

        assert_eq!(d[0].origin.x, 5.0);

5699

        assert_eq!(d[0].size.width, 40.0);

5700

5701

        // Newly present child (absent last frame) counts as changed.

5702

        prev.remove(&dom);

5703

        assert_eq!(compute_virtual_view_damage(&parent, &cur, &prev).len(), 1);

5704

5705

        // Absent in both → nothing to draw, nothing to damage.

5706

        cur.remove(&dom);

5707

        assert!(compute_virtual_view_damage(&parent, &cur, &prev).is_empty());

5708

5709

5710

    /// A BLINKING CARET MUST NOT REPAINT THE DOCUMENT.

5711

///

5712

    /// AzWriter's document body is a `VirtualView`, and the caret lives inside

5713

    /// that child DOM. Measured on X11/CPU before this rule existed, with the

5714

    /// window otherwise completely idle:

5715

///

5716

    ///     [X11 cpu present] total=45.72ms | render=29.90ms blit=15.65ms ...

5717

///

5718

    /// every 1200 ms - the caret-blink interval - because ANY difference in the

5719

    /// child display list damaged the VirtualView's whole on-screen box. The

5720

    /// item diff the parent list already gets was never run on the child, so a

5721

    /// 2x18 caret cost a full-window re-raster AND a full-window swizzle +

5722

    /// XPutImage.

5723

///

5724

    /// The rule: damage what CHANGED inside the view, translated into parent

5725

    /// space and clipped to the view - never the whole view because something

5726

    /// in it moved.

5727

    #[test]

5728

    fn a_caret_blink_inside_a_virtual_view_damages_the_caret_not_the_view() {

5729

        let dom = DomId { inner: 1 };

5730

        // A document viewport the size of a real window body.

5731

        let parent = dlist(vec![DisplayListItem::VirtualView {

5732

            child_dom_id: dom,

5733

            bounds: wlr(10.0, 20.0, 1200.0, 900.0),

5734

            clip_rect: wlr(10.0, 20.0, 1200.0, 900.0),

5735

            content_offset: Default::default(),

5736

        }]);

5737

5738

        // Two frames of the child: identical except the caret, which is on in

5739

        // one and off in the other. Same item count - this is a blink, not a

5740

        // structural change.

5741

        let caret_on = Arc::new(dlist(vec![

5742

            opaque_rect(0.0, 0.0, 1200.0, 40.0),

5743

            opaque_rect(300.0, 400.0, 2.0, 18.0),

5744

        ]));

5745

        let caret_off = Arc::new(dlist(vec![

5746

            opaque_rect(0.0, 0.0, 1200.0, 40.0),

5747

            rect_item(

5748

                300.0,

5749

                400.0,

5750

                2.0,

5751

                18.0,

5752

                ColorU {

5753

                    r: 255,

5754

                    g: 255,

5755

                    b: 255,

5756

                    a: 255,

5757

},

5758

),

5759

        ]));

5760

5761

        let mut cur: BTreeMap<DomId, Arc<DisplayList>> = BTreeMap::new();

5762

        let mut prev: BTreeMap<DomId, Arc<DisplayList>> = BTreeMap::new();

5763

        prev.insert(dom, Arc::clone(&caret_on));

5764

        cur.insert(dom, Arc::clone(&caret_off));

5765

5766

        let d = compute_virtual_view_damage(&parent, &cur, &prev);

5767

        assert!(

5768

            !d.is_empty(),

5769

            "the caret DID change - something must repaint"

5770

);

5771

5772

        let view_area = 1200.0 * 900.0;

5773

        let damaged: f32 = d.iter().map(|r| r.size.width * r.size.height).sum();

5774

        assert!(

5775

            damaged < view_area * 0.01,

5776

            "a 2x18 caret must not damage the document: {damaged}px of {view_area}px in {d:?}"

5777

);

5778

5779

        // ...and it must be damaged where it actually IS on screen: the child

5780

        // list is 0-relative, the view sits at (10, 20).

5781

        let caret = d[0];

5782

        assert!(

5783

            (caret.origin.x - 310.0).abs() < 2.0 && (caret.origin.y - 420.0).abs() < 2.0,

5784

            "caret damage must be translated into parent space, got {caret:?}"

5785

);

5786

5787

5788

    /// The precise path must not leak damage outside the view. A child item

5789

    /// that changed while scrolled out of sight is behind the view's clip, so

5790

    /// repainting its position would dirty a neighbour's pixels.

5791

    #[test]

5792

    fn virtual_view_damage_is_clipped_to_the_view() {

5793

        let dom = DomId { inner: 1 };

5794

        let parent = dlist(vec![DisplayListItem::VirtualView {

5795

            child_dom_id: dom,

5796

            bounds: wlr(0.0, 0.0, 100.0, 50.0),

5797

            clip_rect: wlr(0.0, 0.0, 100.0, 50.0),

5798

            content_offset: Default::default(),

5799

        }]);

5800

        let a = Arc::new(dlist(vec![

5801

            opaque_rect(0.0, 0.0, 10.0, 10.0),

5802

            opaque_rect(0.0, 400.0, 10.0, 10.0),

5803

        ]));

5804

        let b = Arc::new(dlist(vec![

5805

            opaque_rect(0.0, 0.0, 10.0, 10.0),

5806

            opaque_rect(0.0, 400.0, 99.0, 10.0),

5807

        ]));

5808

        let mut cur: BTreeMap<DomId, Arc<DisplayList>> = BTreeMap::new();

5809

        let mut prev: BTreeMap<DomId, Arc<DisplayList>> = BTreeMap::new();

5810

        prev.insert(dom, Arc::clone(&a));

5811

        cur.insert(dom, Arc::clone(&b));

5812

5813

        for r in compute_virtual_view_damage(&parent, &cur, &prev) {

5814

            assert!(

5815

                r.origin.x >= 0.0

5816

                    && r.origin.y >= 0.0

5817

                    && r.origin.x + r.size.width <= 100.0

5818

                    && r.origin.y + r.size.height <= 50.0,

5819

                "damage {r:?} escapes the view box 0,0 100x50"

5820

);

5821

5822

5823

5824

    /// A structural change in the child (the diff cannot pair items) still

5825

    /// falls back to the whole view. Precision is an optimisation; correctness

5826

    /// is not negotiable.

5827

    #[test]

5828

    fn a_structural_child_change_still_damages_the_whole_view() {

5829

        let dom = DomId { inner: 1 };

5830

        let parent = dlist(vec![DisplayListItem::VirtualView {

5831

            child_dom_id: dom,

5832

            bounds: wlr(5.0, 6.0, 40.0, 30.0),

5833

            clip_rect: wlr(5.0, 6.0, 40.0, 30.0),

5834

            content_offset: Default::default(),

5835

        }]);

5836

        // Present last frame, gone this frame: nothing to diff against.

5837

        let only = Arc::new(dlist(vec![opaque_rect(0.0, 0.0, 10.0, 10.0)]));

5838

        let mut cur: BTreeMap<DomId, Arc<DisplayList>> = BTreeMap::new();

5839

        let prev: BTreeMap<DomId, Arc<DisplayList>> = BTreeMap::new();

5840

        cur.insert(dom, Arc::clone(&only));

5841

5842

        let d = compute_virtual_view_damage(&parent, &cur, &prev);

5843

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

5844

        assert_eq!(d[0].size.width, 40.0);

5845

        assert_eq!(d[0].size.height, 30.0);

5846

5847

5848

    // ============================== apply_layer_filters ======================

5849

5850

    #[test]

5851

    fn filters_empty_list_is_a_noop() {

5852

        let mut p = solid(2, 2, [10, 20, 30, 40]);

5853

        apply_layer_filters(&mut p, &[], 1.0);

5854

        assert_eq!(at(&p, 0, 0), [10, 20, 30, 40]);

5855

5856

5857

    #[test]

5858

    fn filter_opacity_saturates_at_both_ends() {

5859

        let mut zero = solid(2, 2, [10, 20, 30, 255]);

5860

        apply_layer_filters(

5861

            &mut zero,

5862

            &[StyleFilter::Opacity(PercentageValue::new(0.0))],

5863

            1.0,

5864

);

5865

        assert_eq!(at(&zero, 0, 0)[3], 0, "0% → fully transparent");

5866

5867

        let mut half = solid(2, 2, [10, 20, 30, 255]);

5868

        apply_layer_filters(

5869

            &mut half,

5870

            &[StyleFilter::Opacity(PercentageValue::new(50.0))],

5871

            1.0,

5872

);

5873

        assert_eq!(at(&half, 0, 0)[3], 127, "50% → 127 (127.5 truncated)");

5874

5875

        let mut over = solid(2, 2, [10, 20, 30, 255]);

5876

        apply_layer_filters(

5877

            &mut over,

5878

            &[StyleFilter::Opacity(PercentageValue::new(500.0))],

5879

            1.0,

5880

);

5881

        assert_eq!(at(&over, 0, 0)[3], 255, "500% must clamp, not wrap");

5882

5883

        let mut neg = solid(2, 2, [10, 20, 30, 255]);

5884

        apply_layer_filters(

5885

            &mut neg,

5886

            &[StyleFilter::Opacity(PercentageValue::new(-100.0))],

5887

            1.0,

5888

);

5889

        assert_eq!(

5890

            at(&neg, 0, 0)[3],

5891

0,

5892

            "a negative percentage clamps to 0, not to 255"

5893

);

5894

        assert_eq!(at(&neg, 0, 0)[0], 10, "RGB is untouched by opacity");

5895

5896

5897

    #[test]

5898

    fn filter_nan_percentage_quantizes_to_zero_and_does_not_panic() {

5899

        // PercentageValue is fixed-point (isize ×1000): `NaN as isize` saturates

5900

        // to 0, so a NaN filter amount degrades to 0% rather than poisoning the

5901

        // pixels with NaN.

5902

        let mut p = solid(2, 2, [200, 100, 50, 255]);

5903

        apply_layer_filters(

5904

            &mut p,

5905

            &[StyleFilter::Grayscale(PercentageValue::new(f32::NAN))],

5906

            1.0,

5907

);

5908

        assert_eq!(

5909

            at(&p, 0, 0),

5910

            [200, 100, 50, 255],

5911

            "NaN amount ⇒ 0% ⇒ identity"

5912

);

5913

5914

5915

    #[test]

5916

    fn filter_brightness_clamps_below_zero_and_above_white() {

5917

        let mut dark = solid(2, 2, [200, 100, 50, 255]);

5918

        apply_layer_filters(

5919

            &mut dark,

5920

            &[StyleFilter::Brightness(PercentageValue::new(-500.0))],

5921

            1.0,

5922

);

5923

        assert_eq!(

5924

            at(&dark, 0, 0),

5925

            [0, 0, 0, 255],

5926

            "negative brightness floors at black"

5927

);

5928

5929

        let mut bright = solid(2, 2, [100, 100, 100, 255]);

5930

        apply_layer_filters(

5931

            &mut bright,

5932

            &[StyleFilter::Brightness(PercentageValue::new(100_000.0))],

5933

            1.0,

5934

);

5935

        assert_eq!(

5936

            at(&bright, 0, 0),

5937

            [255, 255, 255, 255],

5938

            "huge brightness saturates to white"

5939

);

5940

5941

5942

    #[test]

5943

    fn filter_grayscale_and_saturate_agree_at_their_extremes() {

5944

        // luma(255, 0, 0) = 0.2126 * 255 ≈ 54

5945

        let mut gray = solid(2, 2, [255, 0, 0, 255]);

5946

        apply_layer_filters(

5947

            &mut gray,

5948

            &[StyleFilter::Grayscale(PercentageValue::new(100.0))],

5949

            1.0,

5950

);

5951

        let g = at(&gray, 0, 0);

5952

        assert_eq!(

5953

            (g[0], g[1], g[2]),

5954

            (54, 54, 54),

5955

            "full grayscale → luma on every channel"

5956

);

5957

        assert_eq!(g[3], 255, "alpha untouched");

5958

5959

        let mut desat = solid(2, 2, [255, 0, 0, 255]);

5960

        apply_layer_filters(

5961

            &mut desat,

5962

            &[StyleFilter::Saturate(PercentageValue::new(0.0))],

5963

            1.0,

5964

);

5965

        assert_eq!(at(&desat, 0, 0), g, "saturate(0) == grayscale(1)");

5966

5967

5968

    #[test]

5969

    fn filter_grayscale_amount_over_100_percent_is_clamped() {

5970

        let mut a = solid(2, 2, [255, 0, 0, 255]);

5971

        apply_layer_filters(

5972

            &mut a,

5973

            &[StyleFilter::Grayscale(PercentageValue::new(100.0))],

5974

            1.0,

5975

);

5976

        let mut b = solid(2, 2, [255, 0, 0, 255]);

5977

        apply_layer_filters(

5978

            &mut b,

5979

            &[StyleFilter::Grayscale(PercentageValue::new(9999.0))],

5980

            1.0,

5981

);

5982

        assert_eq!(

5983

            at(&a, 0, 0),

5984

            at(&b, 0, 0),

5985

            "amount is clamped to 1.0 — no overshoot"

5986

);

5987

5988

5989

    #[test]

5990

    fn filter_invert_full_inverts_rgb_only() {

5991

        let mut p = solid(2, 2, [0, 0, 255, 200]);

5992

        apply_layer_filters(

5993

            &mut p,

5994

            &[StyleFilter::Invert(PercentageValue::new(100.0))],

5995

            1.0,

5996

);

5997

        assert_eq!(at(&p, 0, 0), [255, 255, 0, 200]);

5998

5999

6000

    #[test]

6001

    fn filter_hue_rotate_by_zero_preserves_the_colour() {

6002

        let mut p = solid(2, 2, [200, 100, 50, 255]);

6003

        apply_layer_filters(&mut p, &[StyleFilter::HueRotate(AngleValue::deg(0.0))], 1.0);

6004

        let g = at(&p, 0, 0);

6005

        for (got, want) in g.iter().zip([200u8, 100, 50, 255].iter()) {

6006

            assert!(

6007

                (i32::from(*got) - i32::from(*want)).abs() <= 2,

6008

                "identity hue rotation must round-trip (±2 for f32 matrix error), got {g:?}"

6009

);

6010

6011

6012

6013

    #[test]

6014

    fn filter_blur_with_no_effective_radius_is_a_noop() {

6015

        let base = solid(8, 8, [10, 20, 30, 255]);

6016

        let blur = |px: f32| {

6017

            StyleFilter::Blur(StyleBlur {

6018

                width: PixelValue::px(px),

6019

                height: PixelValue::px(px),

6020

})

6021

};

6022

6023

        let mut zero = solid(8, 8, [10, 20, 30, 255]);

6024

        apply_layer_filters(&mut zero, &[blur(0.0)], 1.0);

6025

        assert_eq!(zero.data(), base.data(), "0px radius → skipped");

6026

6027

        let mut neg = solid(8, 8, [10, 20, 30, 255]);

6028

        apply_layer_filters(&mut neg, &[blur(-8.0)], 1.0);

6029

        assert_eq!(

6030

            neg.data(),

6031

            base.data(),

6032

            "a negative radius casts to 0, it must not wrap"

6033

);

6034

6035

        let mut nan_dpi = solid(8, 8, [10, 20, 30, 255]);

6036

        apply_layer_filters(&mut nan_dpi, &[blur(4.0)], f32::NAN);

6037

        assert_eq!(nan_dpi.data(), base.data(), "NaN dpi → radius 0 → skipped");

6038

6039

        let mut zero_dpi = solid(8, 8, [10, 20, 30, 255]);

6040

        apply_layer_filters(&mut zero_dpi, &[blur(4.0)], 0.0);

6041

        assert_eq!(zero_dpi.data(), base.data(), "dpi 0 → radius 0 → skipped");

6042

6043

6044

    #[test]

6045

    fn filter_blur_softens_a_hard_edge() {

6046

        let mut p = AzulPixmap::new(16, 16).unwrap();

6047

        p.fill(0, 0, 0, 255);

6048

        p.fill_rect(8, 0, 8, 16, 255, 255, 255, 255); // right half white

6049

        let before = p.data().to_vec();

6050

        apply_layer_filters(

6051

            &mut p,

6052

            &[StyleFilter::Blur(StyleBlur {

6053

                width: PixelValue::px(2.0),

6054

                height: PixelValue::px(2.0),

6055

            })],

6056

            1.0,

6057

);

6058

        assert_ne!(

6059

            p.data(),

6060

            &before[..],

6061

            "a 2px blur must actually change pixels"

6062

);

6063

        assert_eq!(

6064

            p.data().len(),

6065

            before.len(),

6066

            "the buffer must not be reallocated"

6067

);

6068

6069

6070

    #[test]

6071

    fn filter_unimplemented_variants_are_noops() {

6072

        let mut p = solid(2, 2, [10, 20, 30, 255]);

6073

        apply_layer_filters(&mut p, &[StyleFilter::ComponentTransfer], 1.0);

6074

        assert_eq!(at(&p, 0, 0), [10, 20, 30, 255]);

6075

6076

6077

    #[test]

6078

    fn filter_chain_applies_in_order() {

6079

        let mut p = solid(2, 2, [255, 0, 0, 255]);

6080

        apply_layer_filters(

6081

            &mut p,

6082

&[

6083

                StyleFilter::Brightness(PercentageValue::new(0.0)), // → black

6084

                StyleFilter::Invert(PercentageValue::new(100.0)),   // → white

6085

],

6086

            1.0,

6087

);

6088

        assert_eq!(

6089

            at(&p, 0, 0),

6090

            [255, 255, 255, 255],

6091

            "filters must compose left-to-right"

6092

);

6093

6094

6095

    // ============================== allocate_layers_from_display_list ========

6096

6097

    #[test]

6098

    fn allocate_layers_on_empty_display_list_keeps_only_the_root() {

6099

        let mut c = CompositorState::new(64, 64);

6100

        c.allocate_layers_from_display_list(&dlist(vec![]), 1.0, &HashMap::new(), &HashMap::new());

6101

        assert_eq!(c.layers.len(), 1);

6102

        let root = c.layers.get(&c.root_layer).unwrap();

6103

        assert_eq!(root.display_list_range, (0, 0));

6104

        assert!(root.children.is_empty());

6105

6106

6107

    /// A display list that wants one layer of every kind.

6108

    fn layer_soup() -> DisplayList {

6109

        dlist(vec![

6110

            push_scroll(1, 0.0, 0.0, 20.0, 20.0),

6111

            rect_item(

6112

                0.0,

6113

                0.0,

6114

                16.0,

6115

                16.0,

6116

                ColorU {

6117

                    r: 0,

6118

                    g: 0,

6119

                    b: 255,

6120

                    a: 255,

6121

},

6122

),

6123

            DisplayListItem::PopScrollFrame,

6124

            DisplayListItem::PushOpacity {

6125

                bounds: wlr(0.0, 0.0, 20.0, 20.0),

6126

                opacity: 0.5,

6127

                opacity_key: None,

6128

},

6129

            rect_item(

6130

                0.0,

6131

                0.0,

6132

                16.0,

6133

                16.0,

6134

                ColorU {

6135

                    r: 0,

6136

                    g: 0,

6137

                    b: 255,

6138

                    a: 255,

6139

},

6140

),

6141

            DisplayListItem::PopOpacity,

6142

            DisplayListItem::PushFilter {

6143

                bounds: wlr(0.0, 0.0, 20.0, 20.0),

6144

                filters: vec![StyleFilter::Blur(StyleBlur {

6145

                    width: PixelValue::px(2.0),

6146

                    height: PixelValue::px(2.0),

6147

                })],

6148

},

6149

            rect_item(

6150

                0.0,

6151

                0.0,

6152

                16.0,

6153

                16.0,

6154

                ColorU {

6155

                    r: 0,

6156

                    g: 0,

6157

                    b: 255,

6158

                    a: 255,

6159

},

6160

),

6161

            DisplayListItem::PopFilter,

6162

])

6163

6164

6165

    #[test]

6166

    fn allocate_layers_skips_an_empty_scroll_frame() {

6167

        // THE first-draw placeholder-strip bug: an EMPTY scroll frame (every

6168

        // empty TextInput's value <p>) allocated a layer whose pixbuf was

6169

        // never seeded, cleared or rendered - but still composited its

6170

        // never-initialized OPAQUE WHITE pixels over the parent, erasing

6171

        // the sibling placeholder text under it on the first (fully

6172

        // layered) frame. Empty groups must allocate NOTHING, and the pop

6173

        // must not disturb the stack pairing of surrounding frames.

6174

        let mut c = CompositorState::new(64, 64);

6175

        let list = dlist(vec![

6176

            push_scroll(1, 0.0, 0.0, 40.0, 40.0),

6177

            rect_item(

6178

                0.0,

6179

                0.0,

6180

                16.0,

6181

                16.0,

6182

                ColorU {

6183

                    r: 0,

6184

                    g: 0,

6185

                    b: 255,

6186

                    a: 255,

6187

},

6188

),

6189

            push_scroll(2, 2.0, 2.0, 10.0, 10.0),

6190

            DisplayListItem::PopScrollFrame,

6191

            rect_item(

6192

                0.0,

6193

                0.0,

6194

                16.0,

6195

                16.0,

6196

                ColorU {

6197

                    r: 0,

6198

                    g: 0,

6199

                    b: 255,

6200

                    a: 255,

6201

},

6202

),

6203

            DisplayListItem::PopScrollFrame,

6204

]);

6205

        c.allocate_layers_from_display_list(&list, 1.0, &HashMap::new(), &HashMap::new());

6206

        assert_eq!(

6207

            c.layers.len(),

6208

2,

6209

            "root + outer only; the empty inner frame allocates nothing"

6210

);

6211

        let root = c.layers.get(&c.root_layer).unwrap();

6212

        assert_eq!(root.children.len(), 1);

6213

        let outer = c.layers.get(&root.children[0]).unwrap();

6214

        assert_eq!(outer.scroll_id, Some(1));

6215

        assert!(

6216

            outer.children.is_empty(),

6217

            "the empty inner frame must not appear as a child"

6218

);

6219

        assert_eq!(

6220

            outer.display_list_range,

6221

            (1, 5),

6222

            "outer range runs to ITS OWN pop, not the inner one"

6223

);

6224

6225

6226

    #[test]

6227

    fn allocate_layers_at_dpi_one_creates_one_layer_per_group() {

6228

        let mut c = CompositorState::new(64, 64);

6229

        c.allocate_layers_from_display_list(&layer_soup(), 1.0, &HashMap::new(), &HashMap::new());

6230

        assert_eq!(c.layers.len(), 4, "root + scroll + opacity + blur");

6231

        let root = c.layers.get(&c.root_layer).unwrap();

6232

        assert_eq!(

6233

            root.children.len(),

6234

3,

6235

            "all three are direct children of the root"

6236

);

6237

6238

6239

    #[test]

6240

    fn allocate_layers_at_degenerate_dpi_creates_no_layers() {

6241

        for dpi in [0.0_f32, -2.0, f32::NAN] {

6242

            let mut c = CompositorState::new(64, 64);

6243

            c.allocate_layers_from_display_list(

6244

                &layer_soup(),

6245

                dpi,

6246

                &HashMap::new(),

6247

                &HashMap::new(),

6248

);

6249

            assert_eq!(

6250

                c.layers.len(),

6251

1,

6252

                "dpi {dpi} yields a 0-pixel pixbuf — the layer must be skipped, not allocated"

6253

);

6254

6255

6256

6257

    #[test]

6258

    fn allocate_layers_zero_sized_scroll_frame_is_skipped() {

6259

        let mut c = CompositorState::new(64, 64);

6260

        let list = dlist(vec![

6261

            push_scroll(1, 0.0, 0.0, 0.0, 0.0),

6262

            DisplayListItem::PopScrollFrame,

6263

]);

6264

        c.allocate_layers_from_display_list(&list, 1.0, &HashMap::new(), &HashMap::new());

6265

        assert_eq!(c.layers.len(), 1, "a 0×0 clip cannot get a pixbuf");

6266

6267

6268

    #[test]

6269

    fn allocate_layers_scroll_frame_records_id_and_range() {

6270

        let mut c = CompositorState::new(64, 64);

6271

        let list = dlist(vec![

6272

            push_scroll(7, 5.0, 6.0, 20.0, 20.0),

6273

            opaque_rect(0.0, 0.0, 10.0, 10.0),

6274

            DisplayListItem::PopScrollFrame,

6275

]);

6276

        c.allocate_layers_from_display_list(&list, 1.0, &HashMap::new(), &HashMap::new());

6277

        assert_eq!(c.layers.len(), 2);

6278

        let l = c

6279

            .layers

6280

            .values()

6281

            .find(|l| l.scroll_id == Some(7))

6282

            .expect("scroll layer");

6283

        assert_eq!(

6284

            l.display_list_range,

6285

            (1, 2),

6286

            "range is (push+1, matching pop)"

6287

);

6288

        assert_eq!(l.bounds.origin.x, 5.0);

6289

        assert_eq!((l.pixbuf.width(), l.pixbuf.height()), (20, 20));

6290

6291

6292

    #[test]

6293

    fn allocate_layers_unbalanced_pops_do_not_underflow_the_stack() {

6294

        // The doc claims this panics on stack underflow — it must not.

6295

        let mut c = CompositorState::new(64, 64);

6296

        let list = dlist(vec![

6297

            DisplayListItem::PopScrollFrame,

6298

            DisplayListItem::PopOpacity,

6299

            DisplayListItem::PopFilter,

6300

            DisplayListItem::PopReferenceFrame,

6301

            DisplayListItem::PopBackdropFilter,

6302

            DisplayListItem::PopScrollFrame,

6303

]);

6304

        c.allocate_layers_from_display_list(&list, 1.0, &HashMap::new(), &HashMap::new());

6305

        assert_eq!(

6306

            c.layers.len(),

6307

1,

6308

            "stray pops are ignored, the root survives"

6309

);

6310

6311

6312

    #[test]

6313

    fn allocate_layers_unmatched_push_runs_to_the_end_of_the_list() {

6314

        let mut c = CompositorState::new(64, 64);

6315

        let list = dlist(vec![

6316

            push_scroll(1, 0.0, 0.0, 20.0, 20.0),

6317

            opaque_rect(0.0, 0.0, 5.0, 5.0),

6318

]);

6319

        c.allocate_layers_from_display_list(&list, 1.0, &HashMap::new(), &HashMap::new());

6320

        let l = c.layers.values().find(|l| l.scroll_id == Some(1)).unwrap();

6321

        assert_eq!(

6322

            l.display_list_range,

6323

            (1, 2),

6324

            "an unmatched push clamps to items.len()"

6325

);

6326

6327

6328

    #[test]

6329

    fn allocate_layers_opacity_edge_values() {

6330

        // opacity >= 1.0 and NaN must NOT allocate a layer (`*opacity < 1.0`).

6331

        for op in [1.0_f32, 2.0, f32::NAN] {

6332

            let mut c = CompositorState::new(64, 64);

6333

            let list = dlist(vec![

6334

                DisplayListItem::PushOpacity {

6335

                    bounds: wlr(0.0, 0.0, 20.0, 20.0),

6336

                    opacity: op,

6337

                    opacity_key: None,

6338

},

6339

                DisplayListItem::PopOpacity,

6340

]);

6341

            c.allocate_layers_from_display_list(&list, 1.0, &HashMap::new(), &HashMap::new());

6342

            assert_eq!(c.layers.len(), 1, "opacity {op} needs no layer");

6343

6344

        let mut c = CompositorState::new(64, 64);

6345

        let list = dlist(vec![

6346

            DisplayListItem::PushOpacity {

6347

                bounds: wlr(0.0, 0.0, 20.0, 20.0),

6348

                opacity: -3.0,

6349

                opacity_key: None,

6350

},

6351

            rect_item(

6352

                0.0,

6353

                0.0,

6354

                16.0,

6355

                16.0,

6356

                ColorU {

6357

                    r: 0,

6358

                    g: 0,

6359

                    b: 255,

6360

                    a: 255,

6361

},

6362

),

6363

            DisplayListItem::PopOpacity,

6364

]);

6365

        c.allocate_layers_from_display_list(&list, 1.0, &HashMap::new(), &HashMap::new());

6366

        assert_eq!(

6367

            c.layers.len(),

6368

2,

6369

            "a negative opacity still needs its own layer"

6370

);

6371

6372

6373

    #[test]

6374

    fn allocate_layers_identity_reference_frame_is_not_promoted() {

6375

        let mut c = CompositorState::new(64, 64);

6376

        let ident = dlist(vec![ref_frame(1), DisplayListItem::PopReferenceFrame]);

6377

        c.allocate_layers_from_display_list(&ident, 1.0, &HashMap::new(), &HashMap::new());

6378

        assert_eq!(c.layers.len(), 1, "an identity transform needs no layer");

6379

6380

        let mut c2 = CompositorState::new(64, 64);

6381

        let moved = dlist(vec![

6382

            DisplayListItem::PushReferenceFrame {

6383

                transform_key: TransformKey { id: 1 },

6384

                initial_transform: translate(20.0, 10.0),

6385

                bounds: wlr(0.0, 0.0, 20.0, 20.0),

6386

},

6387

            rect_item(

6388

                0.0,

6389

                0.0,

6390

                16.0,

6391

                16.0,

6392

                ColorU {

6393

                    r: 0,

6394

                    g: 0,

6395

                    b: 255,

6396

                    a: 255,

6397

},

6398

),

6399

            DisplayListItem::PopReferenceFrame,

6400

]);

6401

        c2.allocate_layers_from_display_list(&moved, 1.0, &HashMap::new(), &HashMap::new());

6402

        assert_eq!(

6403

            c2.layers.len(),

6404

2,

6405

            "a non-identity transform gets its own layer"

6406

);

6407

        let l = c2.layers.values().find(|l| l.id != c2.root_layer).unwrap();

6408

        assert!(!l.transform.is_identity(IDENTITY_EPSILON_F64));

6409

6410

6411

    /// The matrix baked into a `PushReferenceFrame` is the value at display-list

6412

    /// BUILD time. An animated transform changes every frame without the list

6413

    /// being rebuilt, so layer allocation must read the LIVE value.

6414

///

6415

    /// This is the failure that made engine-driven transitions invisible: the

6416

    /// FLIP seeds a node at identity on the frame the DOM changes, so the baked

6417

    /// matrix is identity, so no layer was promoted — and every later sample

6418

    /// landed in a `transform_stack` that `render_single_item` never reads,

6419

    /// because transforms are realised by layers, not by the item walk. The node

6420

    /// jumped from its old rect to its new one with nothing in between.

6421

    #[test]

6422

    fn allocate_layers_reference_frame_reads_the_live_transform_not_the_baked_one() {

6423

        let mut live: HashMap<usize, ComputedTransform3D> = HashMap::new();

6424

        live.insert(1, translate(120.0, 0.0));

6425

6426

        // Baked identity, live moved: the node IS displaced this frame.

6427

        let mut c = CompositorState::new(64, 64);

6428

        c.allocate_layers_from_display_list(

6429

            &dlist(vec![

6430

                ref_frame(1),

6431

                rect_item(

6432

                    0.0,

6433

                    0.0,

6434

                    16.0,

6435

                    16.0,

6436

                    ColorU {

6437

                        r: 0,

6438

                        g: 0,

6439

                        b: 255,

6440

                        a: 255,

6441

},

6442

),

6443

                DisplayListItem::PopReferenceFrame,

6444

]),

6445

            1.0,

6446

            &live,

6447

            &HashMap::new(),

6448

);

6449

        assert_eq!(

6450

            c.layers.len(),

6451

2,

6452

            "a live-animated frame must be promoted to a layer"

6453

);

6454

        let l = c.layers.values().find(|l| l.id != c.root_layer).unwrap();

6455

        assert!(

6456

            (l.transform.tx - 120.0).abs() < 0.001,

6457

            "layer must carry the LIVE matrix, got tx={}",

6458

            l.transform.tx

6459

);

6460

6461

6462

    /// The reverse direction, and the one that leaves visible damage: a settled

6463

    /// animation publishes identity, and if allocation still trusted the baked

6464

    /// matrix the node would stay permanently offset by a stale sample.

6465

    #[test]

6466

    fn allocate_layers_live_identity_retires_a_baked_transform() {

6467

        let mut live: HashMap<usize, ComputedTransform3D> = HashMap::new();

6468

        live.insert(1, ComputedTransform3D::IDENTITY);

6469

        let mut c = CompositorState::new(64, 64);

6470

        c.allocate_layers_from_display_list(

6471

            &dlist(vec![

6472

                DisplayListItem::PushReferenceFrame {

6473

                    transform_key: TransformKey { id: 1 },

6474

                    initial_transform: translate(20.0, 10.0),

6475

                    bounds: wlr(0.0, 0.0, 20.0, 20.0),

6476

},

6477

                DisplayListItem::PopReferenceFrame,

6478

]),

6479

            1.0,

6480

            &live,

6481

            &HashMap::new(),

6482

);

6483

        assert_eq!(

6484

            c.layers.len(),

6485

1,

6486

            "a settled animation must not keep its layer"

6487

);

6488

6489

6490

    /// Push/pop pairing must not be inferred from the transform VALUE.

6491

///

6492

    /// Allocation skips identity frames, and the pop arm used to decide whether

6493

    /// to pop by asking whether the top layer's transform was non-identity — so

6494

    /// an identity frame nested inside a moved one popped the PARENT, and every

6495

    /// item after it composited into the wrong layer. A FLIP passes through

6496

    /// identity exactly (at rest, and at the instant it settles), so this is

6497

    /// reachable in normal playback rather than only by a hand-built list.

6498

    /// The opacity twin of the live-transform pins: a keyed group's LIVE

6499

    /// value decides promotion, in both directions, and pop pairing is by

6500

    /// recorded decision.

6501

///

6502

    /// An enter/exit fade binds `opacity_key` while the BAKED value is 1.0 —

6503

    /// so without the live lookup a mid-fade group allocated no layer at all

6504

    /// (the fade was invisible), and once the fade settles at exactly 1.0 the

6505

    /// old value-testing pop arm popped the PARENT instead of the group.

6506

    #[test]

6507

    fn allocate_layers_live_opacity_decides_promotion_both_directions() {

6508

        use azul_core::resources::OpacityKey;

6509

        let key = OpacityKey { id: 5 };

6510

        let group = |baked: f32| {

6511

            dlist(vec![

6512

                DisplayListItem::PushOpacity {

6513

                    bounds: wlr(0.0, 0.0, 20.0, 20.0),

6514

                    opacity: baked,

6515

                    opacity_key: Some(key),

6516

},

6517

                opaque_rect(0.0, 0.0, 5.0, 5.0),

6518

                DisplayListItem::PopOpacity,

6519

])

6520

};

6521

        let no_t: HashMap<usize, ComputedTransform3D> = HashMap::new();

6522

6523

        // Mid-fade: baked 1.0, live 0.4 — the group MUST get a layer at the

6524

        // live value.

6525

        let mut live_o: HashMap<usize, f32> = HashMap::new();

6526

        live_o.insert(5, 0.4);

6527

        let mut c = CompositorState::new(64, 64);

6528

        c.allocate_layers_from_display_list(&group(1.0), 1.0, &no_t, &live_o);

6529

        assert_eq!(c.layers.len(), 2, "a mid-fade keyed group needs a layer");

6530

        let l = c.layers.values().find(|l| l.id != c.root_layer).unwrap();

6531

        assert!(

6532

            (l.opacity - 0.4).abs() < 0.001,

6533

            "layer must carry the LIVE opacity"

6534

);

6535

6536

        // Settled fade: live 1.0 beats baked 0.5 — no layer.

6537

        let mut live_one: HashMap<usize, f32> = HashMap::new();

6538

        live_one.insert(5, 1.0);

6539

        let mut c2 = CompositorState::new(64, 64);

6540

        c2.allocate_layers_from_display_list(&group(0.5), 1.0, &no_t, &live_one);

6541

        assert_eq!(c2.layers.len(), 1, "a settled fade must not keep its layer");

6542

6543

6544

    /// Pop pairing for opacity groups is by recorded decision: a keyed group

6545

    /// whose live value is exactly 1.0 (a completed fade) allocates nothing,

6546

    /// and its `PopOpacity` must NOT pop the enclosing moved reference frame.

6547

    #[test]

6548

    fn allocate_layers_completed_fade_does_not_pop_its_moved_parent() {

6549

        use azul_core::resources::OpacityKey;

6550

        let mut live_t: HashMap<usize, ComputedTransform3D> = HashMap::new();

6551

        live_t.insert(1, translate(30.0, 0.0));

6552

        let mut live_o: HashMap<usize, f32> = HashMap::new();

6553

        live_o.insert(9, 1.0); // the fade has completed

6554

6555

        let mut c = CompositorState::new(64, 64);

6556

        c.allocate_layers_from_display_list(

6557

            &dlist(vec![

6558

                ref_frame(1),

6559

                DisplayListItem::PushOpacity {

6560

                    bounds: wlr(0.0, 0.0, 10.0, 10.0),

6561

                    opacity: 1.0,

6562

                    opacity_key: Some(OpacityKey { id: 9 }),

6563

},

6564

                DisplayListItem::PopOpacity,     // allocated nothing

6565

                opaque_rect(0.0, 0.0, 5.0, 5.0), // still inside the FRAME

6566

                DisplayListItem::PopReferenceFrame,

6567

]),

6568

            1.0,

6569

            &live_t,

6570

            &live_o,

6571

);

6572

        assert_eq!(c.layers.len(), 2, "only the moved frame gets a layer");

6573

        let frame_id = *c

6574

            .layers

6575

            .get(&c.root_layer)

6576

            .unwrap()

6577

            .children

6578

            .first()

6579

            .unwrap();

6580

        let frame = c.layers.get(&frame_id).unwrap();

6581

        let (start, end) = frame.display_list_range;

6582

        assert!(

6583

            start <= 3 && end > 3,

6584

            "the rect at index 3 sits inside the frame, but its layer spans {start}..{end}"

6585

);

6586

6587

6588

    #[test]

6589

    fn allocate_layers_identity_child_frame_does_not_pop_its_moved_parent() {

6590

        let mut live: HashMap<usize, ComputedTransform3D> = HashMap::new();

6591

        live.insert(1, translate(30.0, 0.0)); // outer: moving

6592

        live.insert(2, ComputedTransform3D::IDENTITY); // inner: at rest

6593

6594

        let mut c = CompositorState::new(64, 64);

6595

        c.allocate_layers_from_display_list(

6596

            &dlist(vec![

6597

                ref_frame(1),

6598

                ref_frame(2),

6599

                DisplayListItem::PopReferenceFrame, // inner — allocated nothing

6600

                opaque_rect(0.0, 0.0, 5.0, 5.0),    // still inside the OUTER frame

6601

                DisplayListItem::PopReferenceFrame, // outer

6602

                opaque_rect(0.0, 0.0, 5.0, 5.0),    // back at the root

6603

]),

6604

            1.0,

6605

            &live,

6606

            &HashMap::new(),

6607

);

6608

        assert_eq!(c.layers.len(), 2, "only the moved outer frame gets a layer");

6609

        let outer_id = *c

6610

            .layers

6611

            .get(&c.root_layer)

6612

            .unwrap()

6613

            .children

6614

            .first()

6615

            .unwrap();

6616

        let outer = c.layers.get(&outer_id).unwrap();

6617

        let (start, end) = outer.display_list_range;

6618

        assert!(

6619

            start <= 3 && end > 3,

6620

            "the rect at index 3 sits inside the outer frame, but its layer spans {start}..{end}"

6621

);

6622

6623

6624

    #[test]

6625

    fn allocate_layers_nests_children_under_their_parent() {

6626

        let mut c = CompositorState::new(64, 64);

6627

        let list = dlist(vec![

6628

            push_scroll(1, 0.0, 0.0, 40.0, 40.0),

6629

            push_scroll(2, 0.0, 0.0, 20.0, 20.0),

6630

            opaque_rect(0.0, 0.0, 5.0, 5.0),

6631

            DisplayListItem::PopScrollFrame,

6632

            DisplayListItem::PopScrollFrame,

6633

]);

6634

        c.allocate_layers_from_display_list(&list, 1.0, &HashMap::new(), &HashMap::new());

6635

        assert_eq!(c.layers.len(), 3);

6636

        let root = c.layers.get(&c.root_layer).unwrap();

6637

        assert_eq!(

6638

            root.children.len(),

6639

1,

6640

            "only the outer frame hangs off the root"

6641

);

6642

        let outer_id = root.children[0];

6643

        let outer = c.layers.get(&outer_id).unwrap();

6644

        assert_eq!(outer.scroll_id, Some(1));

6645

        assert_eq!(

6646

            outer.children.len(),

6647

1,

6648

            "the inner frame is a child of the outer one"

6649

);

6650

        let inner = c.layers.get(&outer.children[0]).unwrap();

6651

        assert_eq!(inner.scroll_id, Some(2));

6652

        assert_eq!(inner.display_list_range, (2, 3));

6653

6654

6655

    #[test]

6656

    fn allocate_layers_is_idempotent_across_frames() {

6657

        let mut c = CompositorState::new(64, 64);

6658

        c.allocate_layers_from_display_list(&layer_soup(), 1.0, &HashMap::new(), &HashMap::new());

6659

        let first = c.layers.len();

6660

        c.allocate_layers_from_display_list(&layer_soup(), 1.0, &HashMap::new(), &HashMap::new());

6661

        assert_eq!(

6662

            c.layers.len(),

6663

            first,

6664

            "re-allocating must not leak last frame's layers"

6665

);

6666

        let root = c.layers.get(&c.root_layer).unwrap();

6667

        assert_eq!(

6668

            root.children.len(),

6669

3,

6670

            "root children are rebuilt, not appended to"

6671

);

6672

        assert!(

6673

            c.next_layer_id_peek() > first as u64,

6674

            "ids stay monotonic across frames"

6675

);

6676

6677

6678

    #[test]

6679

    fn allocate_layers_backdrop_filter_starts_transparent() {

6680

        let mut c = CompositorState::new(64, 64);

6681

        let list = dlist(vec![

6682

            DisplayListItem::PushBackdropFilter {

6683

                bounds: wlr(0.0, 0.0, 20.0, 20.0),

6684

                filters: vec![StyleFilter::Invert(PercentageValue::new(100.0))],

6685

},

6686

            DisplayListItem::PopBackdropFilter,

6687

]);

6688

        c.allocate_layers_from_display_list(&list, 1.0, &HashMap::new(), &HashMap::new());

6689

        let l = c

6690

            .layers

6691

            .values()

6692

            .find(|l| l.is_backdrop_filter)

6693

            .expect("backdrop layer");

6694

        assert_eq!(

6695

            at(&l.pixbuf, 0, 0),

6696

            [0, 0, 0, 0],

6697

            "an empty backdrop-filter box must not blit opaque white over the backdrop"

6698

);

6699

6700

        // With no filters at all it is NOT a backdrop layer.

6701

        let mut c2 = CompositorState::new(64, 64);

6702

        let empty = dlist(vec![

6703

            DisplayListItem::PushBackdropFilter {

6704

                bounds: wlr(0.0, 0.0, 20.0, 20.0),

6705

                filters: Vec::new(),

6706

},

6707

            DisplayListItem::PopBackdropFilter,

6708

]);

6709

        c2.allocate_layers_from_display_list(&empty, 1.0, &HashMap::new(), &HashMap::new());

6710

        assert_eq!(c2.layers.len(), 1, "no filters → no layer");

6711

6712

6713

    // ============================== compute_damage ===========================

6714

6715

    #[test]

6716

    fn compute_damage_with_no_dirty_nodes_is_a_noop() {

6717

        let mut c = CompositorState::new(64, 64);

6718

        c.compute_damage(&BTreeSet::new(), &[], &[], &[]);

6719

        assert!(c.layers.get(&c.root_layer).unwrap().damage.is_empty());

6720

6721

6722

    #[test]

6723

    fn compute_damage_ignores_out_of_range_node_indices() {

6724

        let mut c = CompositorState::new(64, 64);

6725

        let dirty: BTreeSet<usize> = [0usize, 5, usize::MAX].into_iter().collect();

6726

        // Every slice is empty → every index is out of range → guarded, no panic.

6727

        c.compute_damage(&dirty, &[], &[], &[]);

6728

        assert!(c.layers.get(&c.root_layer).unwrap().damage.is_empty());

6729

6730

6731

    #[test]

6732

    fn compute_damage_covers_the_old_and_the_new_position() {

6733

        let mut c = CompositorState::new(64, 64);

6734

        let dirty: BTreeSet<usize> = [0usize].into_iter().collect();

6735

        let old = [LogicalPosition::new(0.0, 0.0)];

6736

        let new = [LogicalPosition::new(20.0, 20.0)];

6737

        let rects = [lr(0.0, 0.0, 10.0, 10.0)];

6738

        c.compute_damage(&dirty, &old, &new, &rects);

6739

        let root = c.layers.get(&c.root_layer).unwrap();

6740

        assert_eq!(

6741

            root.damage.len(),

6742

2,

6743

            "a moved node damages where it was AND where it is"

6744

);

6745

        assert!(root.composite_dirty);

6746

        assert!(root.damage.iter().any(|d| d.origin.x == 0.0));

6747

        assert!(root.damage.iter().any(|d| d.origin.x == 20.0));

6748

6749

6750

    #[test]

6751

    fn compute_damage_with_nan_positions_does_not_leak_nan() {

6752

        // `rect_intersection` uses f32::max/min, which IGNORE NaN — so a NaN

6753

        // node degrades to whole-layer damage (conservative) rather than to

6754

        // `None`. Either way, no NaN may reach a damage rect: a NaN rect would

6755

        // silently rasterise to nothing and the node would never repaint.

6756

        let mut c = CompositorState::new(64, 64);

6757

        let dirty: BTreeSet<usize> = [0usize].into_iter().collect();

6758

        let nan = [LogicalPosition::new(f32::NAN, f32::NAN)];

6759

        let rects = [lr(0.0, 0.0, f32::NAN, f32::NAN)];

6760

        c.compute_damage(&dirty, &nan, &nan, &rects);

6761

        let root = c.layers.get(&c.root_layer).unwrap();

6762

        for d in &root.damage {

6763

            assert!(

6764

                d.origin.x.is_finite()

6765

                    && d.origin.y.is_finite()

6766

                    && d.size.width.is_finite()

6767

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

6768

                "NaN must not leak into a damage rect, got {d:?}"

6769

);

6770

6771

6772

6773

    #[test]

6774

    fn compute_damage_clips_to_the_layer_bounds() {

6775

        let mut c = CompositorState::new(64, 64);

6776

        let dirty: BTreeSet<usize> = [0usize].into_iter().collect();

6777

        let pos = [LogicalPosition::new(60.0, 60.0)];

6778

        let rects = [lr(0.0, 0.0, 100.0, 100.0)];

6779

        c.compute_damage(&dirty, &pos, &pos, &rects);

6780

        let root = c.layers.get(&c.root_layer).unwrap();

6781

        for d in &root.damage {

6782

            assert!(

6783

                d.origin.x + d.size.width <= 64.0 && d.origin.y + d.size.height <= 64.0,

6784

                "damage must be clipped to the layer, got {d:?}"

6785

);

6786

6787

6788

6789

    // ============================== render_layers / composite_frame ==========

6790

6791

    #[test]

6792

    fn render_layers_on_an_empty_display_list_is_ok() {

6793

        let mut c = CompositorState::new(8, 8);

6794

        let list = dlist(vec![]);

6795

        c.allocate_layers_from_display_list(&list, 1.0, &HashMap::new(), &HashMap::new());

6796

        let (rr, mut gc, st) = render_deps();

6797

        assert!(c

6798

            .render_layers(&list, 1.0, &rr, &test_font_manager(), &mut gc, &st)

6799

            .is_ok());

6800

6801

6802

    #[test]

6803

    fn render_layers_paints_a_rect_into_the_root_pixbuf() {

6804

        let mut c = CompositorState::new(16, 16);

6805

        let list = dlist(vec![rect_item(

6806

            0.0,

6807

            0.0,

6808

            16.0,

6809

            16.0,

6810

            ColorU {

6811

                r: 0,

6812

                g: 0,

6813

                b: 255,

6814

                a: 255,

6815

},

6816

        )]);

6817

        c.allocate_layers_from_display_list(&list, 1.0, &HashMap::new(), &HashMap::new());

6818

        let (rr, mut gc, st) = render_deps();

6819

        c.render_layers(&list, 1.0, &rr, &test_font_manager(), &mut gc, &st)

6820

            .unwrap();

6821

        let root = c.layers.get(&c.root_layer).unwrap();

6822

        assert_eq!(at(&root.pixbuf, 8, 8), [0, 0, 255, 255]);

6823

6824

        let mut out = AzulPixmap::new(16, 16).unwrap();

6825

        out.fill(0, 0, 0, 255);

6826

        c.composite_frame(&mut out, 1.0);

6827

        assert_eq!(

6828

            at(&out, 8, 8),

6829

            [0, 0, 255, 255],

6830

            "the root layer is blitted 1:1"

6831

);

6832

6833

6834

    #[test]

6835

    fn render_layers_survives_degenerate_dpi_factors() {

6836

        // A non-finite / non-positive scale makes every rect un-rasterisable;

6837

        // the renderer must skip it and still return Ok with a cleared root.

6838

        for dpi in [0.0_f32, -1.0, f32::NAN, f32::INFINITY] {

6839

            let mut c = CompositorState::new(8, 8);

6840

            let list = dlist(vec![rect_item(

6841

                0.0,

6842

                0.0,

6843

                8.0,

6844

                8.0,

6845

                ColorU {

6846

                    r: 0,

6847

                    g: 0,

6848

                    b: 255,

6849

                    a: 255,

6850

},

6851

            )]);

6852

            c.allocate_layers_from_display_list(&list, dpi, &HashMap::new(), &HashMap::new());

6853

            let (rr, mut gc, st) = render_deps();

6854

            assert!(

6855

                c.render_layers(&list, dpi, &rr, &test_font_manager(), &mut gc, &st)

6856

                    .is_ok(),

6857

                "dpi {dpi} must not error or panic"

6858

);

6859

            let root = c.layers.get(&c.root_layer).unwrap();

6860

            assert_eq!(

6861

                at(&root.pixbuf, 4, 4),

6862

                [255, 255, 255, 255],

6863

                "dpi {dpi} rasterises nothing — the root stays cleared to white"

6864

);

6865

6866

6867

6868

    #[test]

6869

    fn render_layers_skips_a_layer_range_past_the_end_of_the_list() {

6870

        let mut c = CompositorState::new(8, 8);

6871

        let list = dlist(vec![opaque_rect(0.0, 0.0, 8.0, 8.0)]);

6872

        c.allocate_layers_from_display_list(&list, 1.0, &HashMap::new(), &HashMap::new());

6873

        // Simulate a stale range left over from a longer display list.

6874

        let root_id = c.root_layer;

6875

        c.layers.get_mut(&root_id).unwrap().display_list_range = (999, 1000);

6876

        let (rr, mut gc, st) = render_deps();

6877

        assert!(

6878

            c.render_layers(&list, 1.0, &rr, &test_font_manager(), &mut gc, &st)

6879

                .is_ok(),

6880

            "an out-of-range range must be skipped, not indexed"

6881

);

6882

6883

6884

    #[test]

6885

    fn render_layers_clamps_a_range_that_overruns_the_list() {

6886

        let mut c = CompositorState::new(8, 8);

6887

        let list = dlist(vec![rect_item(

6888

            0.0,

6889

            0.0,

6890

            8.0,

6891

            8.0,

6892

            ColorU {

6893

                r: 0,

6894

                g: 255,

6895

                b: 0,

6896

                a: 255,

6897

},

6898

        )]);

6899

        c.allocate_layers_from_display_list(&list, 1.0, &HashMap::new(), &HashMap::new());

6900

        let root_id = c.root_layer;

6901

        c.layers.get_mut(&root_id).unwrap().display_list_range = (0, 9999);

6902

        let (rr, mut gc, st) = render_deps();

6903

        c.render_layers(&list, 1.0, &rr, &test_font_manager(), &mut gc, &st)

6904

            .unwrap();

6905

        let root = c.layers.get(&c.root_layer).unwrap();

6906

        assert_eq!(

6907

            at(&root.pixbuf, 4, 4),

6908

            [0, 255, 0, 255],

6909

            "end is clamped to items.len()"

6910

);

6911

6912

6913

    #[test]

6914

    fn composite_frame_handles_degenerate_dpi_and_undersized_output() {

6915

        let mut c = CompositorState::new(16, 16);

6916

        let list = dlist(vec![]);

6917

        c.allocate_layers_from_display_list(&list, 1.0, &HashMap::new(), &HashMap::new());

6918

        let (rr, mut gc, st) = render_deps();

6919

        c.render_layers(&list, 1.0, &rr, &test_font_manager(), &mut gc, &st)

6920

            .unwrap();

6921

6922

        for dpi in [0.0_f32, -1.0, f32::NAN] {

6923

            let mut out = AzulPixmap::new(16, 16).unwrap();

6924

            out.fill(0, 0, 0, 255);

6925

            c.composite_frame(&mut out, dpi);

6926

            assert_eq!(

6927

                at(&out, 0, 0),

6928

                [255, 255, 255, 255],

6929

                "root blit ignores dpi {dpi}"

6930

);

6931

6932

6933

        // Output smaller than the root layer: the blit must clip, not panic.

6934

        let mut small = AzulPixmap::new(4, 4).unwrap();

6935

        small.fill(0, 0, 0, 255);

6936

        c.composite_frame(&mut small, 1.0);

6937

        assert_eq!(at(&small, 3, 3), [255, 255, 255, 255]);

6938

6939

6940

    #[test]

6941

    fn composite_frame_applies_layer_opacity() {

6942

        let mut c = CompositorState::new(16, 16);

6943

        let list = dlist(vec![

6944

            DisplayListItem::PushOpacity {

6945

                bounds: wlr(0.0, 0.0, 16.0, 16.0),

6946

                opacity: 0.0, // fully transparent group

6947

                opacity_key: None,

6948

},

6949

            rect_item(

6950

                0.0,

6951

                0.0,

6952

                16.0,

6953

                16.0,

6954

                ColorU {

6955

                    r: 255,

6956

                    g: 0,

6957

                    b: 0,

6958

                    a: 255,

6959

},

6960

),

6961

            DisplayListItem::PopOpacity,

6962

]);

6963

        c.allocate_layers_from_display_list(&list, 1.0, &HashMap::new(), &HashMap::new());

6964

        let (rr, mut gc, st) = render_deps();

6965

        c.render_layers(&list, 1.0, &rr, &test_font_manager(), &mut gc, &st)

6966

            .unwrap();

6967

        let mut out = AzulPixmap::new(16, 16).unwrap();

6968

        out.fill(0, 0, 0, 255);

6969

        c.composite_frame(&mut out, 1.0);

6970

        assert_eq!(

6971

            at(&out, 8, 8),

6972

            [255, 255, 255, 255],

6973

            "an opacity-0 layer must contribute nothing over the white root"

6974

);

6975

6976

6977

    // ================= windowed structural display-list damage ===============

6978

6979

    /// THE CLASS (dl_text_patch on ubuntu, 2026-08-24): retyping a

6980

    /// paragraph's text so it wraps to one more line emits one more Text

6981

    /// item; the item-count check bailed the whole diff to a FULL repaint —

6982

    /// font-metrics dependent, so green on macOS and red on DejaVu. A

6983

    /// localized structural change now damages the changed middle window.

6984

    #[test]

6985

    fn a_changed_item_count_damages_the_changed_window_not_the_full_frame() {

6986

        let red = ColorU {

6987

            r: 255,

6988

            g: 0,

6989

            b: 0,

6990

            a: 255,

6991

};

6992

        let blue = ColorU {

6993

            r: 0,

6994

            g: 0,

6995

            b: 255,

6996

            a: 255,

6997

};

6998

        let old = dlist(vec![

6999

            rect_item(0.0, 0.0, 100.0, 10.0, red),

7000

            rect_item(0.0, 20.0, 100.0, 10.0, red),

7001

            rect_item(0.0, 500.0, 100.0, 10.0, red),

7002

]);

7003

        let new = dlist(vec![

7004

            rect_item(0.0, 0.0, 100.0, 10.0, red),

7005

            rect_item(0.0, 20.0, 100.0, 10.0, blue),

7006

            rect_item(0.0, 32.0, 100.0, 10.0, blue), // the inserted "new line"

7007

            rect_item(0.0, 500.0, 100.0, 10.0, red),

7008

]);

7009

        let off = ScrollOffsetMap::new();

7010

        let damage = compute_display_list_damage(&old, &new, &off, &off)

7011

            .expect("a localized insertion must yield rect damage, not a full repaint");

7012

        assert!(!damage.is_empty());

7013

        for r in &damage {

7014

            assert!(

7015

                r.origin.y >= 19.0 && r.origin.y + r.size.height <= 43.0,

7016

                "damage stays in the changed window (the shared prefix/suffix are untouched): \

7017

                 {r:?}"

7018

);

7019

7020

7021

7022

    /// The fallback maps the changed window through the scroll stack, and

7023

    /// keeps the full-repaint bail when the offsets themselves changed.

7024

    #[test]

7025

    fn windowed_damage_respects_scroll_offsets() {

7026

        let red = ColorU {

7027

            r: 255,

7028

            g: 0,

7029

            b: 0,

7030

            a: 255,

7031

};

7032

        let old = dlist(vec![

7033

            push_scroll(1, 0.0, 0.0, 100.0, 50.0),

7034

            rect_item(0.0, 100.0, 100.0, 10.0, red),

7035

            DisplayListItem::PopScrollFrame,

7036

]);

7037

        let new = dlist(vec![

7038

            push_scroll(1, 0.0, 0.0, 100.0, 50.0),

7039

            rect_item(0.0, 100.0, 100.0, 10.0, red),

7040

            rect_item(0.0, 112.0, 100.0, 10.0, red),

7041

            DisplayListItem::PopScrollFrame,

7042

]);

7043

        let mut off = ScrollOffsetMap::new();

7044

        off.insert(1, (0.0, 90.0));

7045

        let damage = compute_display_list_damage(&old, &new, &off, &off)

7046

            .expect("insertion inside an (unchanged) scrolled frame yields rects");

7047

        assert!(

7048

            damage.iter().any(|r| (r.origin.y - 22.0).abs() < 1.0),

7049

            "content coords minus the 90px scroll offset: {damage:?}"

7050

);

7051

7052

        let mut moved = ScrollOffsetMap::new();

7053

        moved.insert(1, (0.0, 40.0));

7054

        assert!(

7055

            compute_display_list_damage(&old, &new, &off, &moved).is_none(),

7056

            "a structural change WHILE the offsets changed keeps the full-repaint bail"

7057

);

7058

7059

7060

    // ===================== nested scroll-frame compositing ===================

7061

7062

    /// A `PushClip` WRAPPING a nested layer joins the chain: the layer's

7063

    /// pixels stay inside the clip at composite time (item-level clipping

7064

    /// inside one layer was always handled by the rasterizer; the layer

7065

    /// boundary was the hole).

7066

    #[test]

7067

    fn a_push_clip_wrapping_a_nested_layer_clips_it_at_composite() {

7068

        let mut c = CompositorState::new(64, 64);

7069

        let red = ColorU {

7070

            r: 255,

7071

            g: 0,

7072

            b: 0,

7073

            a: 255,

7074

};

7075

        let list = dlist(vec![

7076

            DisplayListItem::PushClip {

7077

                bounds: wlr(10.0, 10.0, 20.0, 20.0),

7078

                border_radius: BorderRadius::default(),

7079

},

7080

            push_scroll(1, 10.0, 10.0, 40.0, 40.0),

7081

            rect_item(10.0, 10.0, 40.0, 40.0, red),

7082

            DisplayListItem::PopScrollFrame,

7083

            DisplayListItem::PopClip,

7084

]);

7085

        c.allocate_layers_from_display_list(&list, 1.0, &HashMap::new(), &HashMap::new());

7086

        let (rr, mut gc, st) = render_deps();

7087

        c.render_layers(&list, 1.0, &rr, &test_font_manager(), &mut gc, &st)

7088

            .unwrap();

7089

        let mut out = AzulPixmap::new(64, 64).unwrap();

7090

        out.fill(255, 255, 255, 255);

7091

        c.composite_frame(&mut out, 1.0);

7092

        assert_eq!(

7093

            at(&out, 25, 25),

7094

            [255, 0, 0, 255],

7095

            "inside the wrapping clip"

7096

);

7097

        assert_eq!(

7098

            at(&out, 35, 15),

7099

            [255, 255, 255, 255],

7100

            "the scroll layer's pixels outside the WRAPPING PushClip are clipped"

7101

);

7102

        assert_eq!(at(&out, 15, 35), [255, 255, 255, 255], "both axes");

7103

7104

7105

    /// THE CLASS (AzWidgets TextArea, 2026-08-24): a layer nested inside a

7106

    /// NON-root layer composited at parent origin + its own absolute origin —

7107

    /// every ancestor origin double-counted — so its pixels landed below and

7108

    /// right of where layout and hit-testing put them.

7109

    #[test]

7110

    fn a_nested_scroll_frame_composites_parent_relative_not_double_offset() {

7111

        let mut c = CompositorState::new(64, 64);

7112

        let red = ColorU {

7113

            r: 255,

7114

            g: 0,

7115

            b: 0,

7116

            a: 255,

7117

};

7118

        let list = dlist(vec![

7119

            push_scroll(1, 10.0, 10.0, 40.0, 40.0),

7120

            push_scroll(2, 20.0, 20.0, 20.0, 20.0),

7121

            rect_item(20.0, 20.0, 20.0, 20.0, red),

7122

            DisplayListItem::PopScrollFrame,

7123

            DisplayListItem::PopScrollFrame,

7124

]);

7125

        c.allocate_layers_from_display_list(&list, 1.0, &HashMap::new(), &HashMap::new());

7126

        let (rr, mut gc, st) = render_deps();

7127

        c.render_layers(&list, 1.0, &rr, &test_font_manager(), &mut gc, &st)

7128

            .unwrap();

7129

        let mut out = AzulPixmap::new(64, 64).unwrap();

7130

        out.fill(255, 255, 255, 255);

7131

        c.composite_frame(&mut out, 1.0);

7132

        assert_eq!(

7133

            at(&out, 22, 22),

7134

            [255, 0, 0, 255],

7135

            "the nested frame's rect paints at its LAYOUT position (20..40)"

7136

);

7137

        assert_eq!(

7138

            at(&out, 48, 48),

7139

            [255, 255, 255, 255],

7140

            "…and NOT at the double-offset position (30..50) the old absolute placement produced"

7141

);

7142

7143

7144

    /// Scrolling the OUTER frame must move a nested frame's pixels with the

7145

    /// content, and clip them at the outer frame's edge — the nested layer's

7146

    /// pixels do not live in the outer layer's backing, so both effects come

7147

    /// from the composite step alone.

7148

    #[test]

7149

    fn scrolling_the_outer_frame_moves_and_clips_the_nested_frame() {

7150

        let mut c = CompositorState::new(64, 64);

7151

        let red = ColorU {

7152

            r: 255,

7153

            g: 0,

7154

            b: 0,

7155

            a: 255,

7156

};

7157

        let list = dlist(vec![

7158

            push_scroll(1, 10.0, 10.0, 40.0, 40.0),

7159

            push_scroll(2, 20.0, 20.0, 20.0, 20.0),

7160

            rect_item(20.0, 20.0, 20.0, 20.0, red),

7161

            DisplayListItem::PopScrollFrame,

7162

            DisplayListItem::PopScrollFrame,

7163

]);

7164

        c.allocate_layers_from_display_list(&list, 1.0, &HashMap::new(), &HashMap::new());

7165

        let (rr, mut gc, _st) = render_deps();

7166

        let mut offsets = ScrollOffsetMap::new();

7167

        offsets.insert(1, (0.0, 15.0));

7168

        let st = CpuRenderState::new(offsets);

7169

        c.render_layers(&list, 1.0, &rr, &test_font_manager(), &mut gc, &st)

7170

            .unwrap();

7171

        let mut out = AzulPixmap::new(64, 64).unwrap();

7172

        out.fill(255, 255, 255, 255);

7173

        c.composite_frame(&mut out, 1.0);

7174

        // The rect's visual band moves from y 20..40 to y 5..25, clipped by

7175

        // the outer frame's rect to y 10..25.

7176

        assert_eq!(

7177

            at(&out, 22, 12),

7178

            [255, 0, 0, 255],

7179

            "scrolling the outer frame moves the nested frame's pixels up"

7180

);

7181

        assert_eq!(

7182

            at(&out, 22, 8),

7183

            [255, 255, 255, 255],

7184

            "…and the part scrolled past the outer frame's top edge is CLIPPED"

7185

);

7186

        assert_eq!(

7187

            at(&out, 22, 30),

7188

            [255, 255, 255, 255],

7189

            "…and the vacated band below is no longer red"

7190

);

7191

7192

7193

    // ============================== scroll_layer =============================

7194

7195

    #[test]

7196

    fn scroll_layer_with_an_unknown_id_is_ok() {

7197

        let mut c = CompositorState::new(32, 32);

7198

        let list = dlist(vec![]);

7199

        c.allocate_layers_from_display_list(&list, 1.0, &HashMap::new(), &HashMap::new());

7200

        let (rr, mut gc, _st) = render_deps();

7201

        assert!(

7202

            c.scroll_layer(

7203

                4242,

7204

                (0.0, 10.0),

7205

                &list,

7206

                1.0,

7207

                &rr,

7208

                &test_font_manager(),

7209

                &mut gc

7210

7211

            .is_ok(),

7212

            "scrolling a frame that has no layer is a no-op, not a panic"

7213

);

7214

7215

7216

    #[test]

7217

    fn scroll_layer_ignores_subpixel_deltas() {

7218

        let mut c = CompositorState::new(32, 32);

7219

        let list = dlist(vec![

7220

            push_scroll(1, 0.0, 0.0, 32.0, 32.0),

7221

            opaque_rect(0.0, 0.0, 32.0, 200.0),

7222

            DisplayListItem::PopScrollFrame,

7223

]);

7224

        c.allocate_layers_from_display_list(&list, 1.0, &HashMap::new(), &HashMap::new());

7225

        let (rr, mut gc, _st) = render_deps();

7226

        c.scroll_layer(

7227

1,

7228

            (0.0, 0.4),

7229

            &list,

7230

            1.0,

7231

            &rr,

7232

            &test_font_manager(),

7233

            &mut gc,

7234

7235

        .unwrap();

7236

        let l = c.layers.values().find(|l| l.scroll_id == Some(1)).unwrap();

7237

        assert_eq!(

7238

            l.scroll_offset,

7239

            (0.0, 0.0),

7240

            "|dy| < 0.5 must not move anything"

7241

);

7242

        assert!(l.damage.is_empty());

7243

7244

7245

    #[test]

7246

    fn scroll_layer_updates_offset_and_records_the_exposed_strip() {

7247

        let mut c = CompositorState::new(32, 32);

7248

        let list = dlist(vec![

7249

            push_scroll(1, 0.0, 0.0, 32.0, 32.0),

7250

            opaque_rect(0.0, 0.0, 32.0, 200.0),

7251

            DisplayListItem::PopScrollFrame,

7252

]);

7253

        c.allocate_layers_from_display_list(&list, 1.0, &HashMap::new(), &HashMap::new());

7254

        let (rr, mut gc, _st) = render_deps();

7255

        c.scroll_layer(

7256

1,

7257

            (0.0, 10.0),

7258

            &list,

7259

            1.0,

7260

            &rr,

7261

            &test_font_manager(),

7262

            &mut gc,

7263

7264

        .unwrap();

7265

        let l = c.layers.values().find(|l| l.scroll_id == Some(1)).unwrap();

7266

        assert_eq!(l.scroll_offset, (0.0, 10.0));

7267

        assert_eq!(l.damage.len(), 1, "a single-axis scroll exposes one strip");

7268

        assert!(l.composite_dirty);

7269

7270

7271

    // ============================== render_display_list_range ================

7272

7273

    #[test]

7274

    fn render_range_with_start_after_end_is_ok() {

7275

        let list = dlist(vec![opaque_rect(0.0, 0.0, 4.0, 4.0)]);

7276

        let mut p = solid(4, 4, [255, 255, 255, 255]);

7277

        let (rr, mut gc, st) = render_deps();

7278

        let r = render_display_list_range(

7279

            &list,

7280

            &mut p,

7281

5,

7282

2,

7283

            &[],

7284

            0.0,

7285

            0.0,

7286

            1.0,

7287

            &rr,

7288

            &test_font_manager(),

7289

            &mut gc,

7290

            &st,

7291

);

7292

        assert!(

7293

            r.is_ok(),

7294

            "an inverted range is an empty range, not a panic"

7295

);

7296

        assert_eq!(at(&p, 0, 0), [255, 255, 255, 255], "nothing was drawn");

7297

7298

7299

    #[test]

7300

    fn render_range_honours_skip_ranges() {

7301

        let list = dlist(vec![rect_item(

7302

            0.0,

7303

            0.0,

7304

            4.0,

7305

            4.0,

7306

            ColorU {

7307

                r: 255,

7308

                g: 0,

7309

                b: 0,

7310

                a: 255,

7311

},

7312

        )]);

7313

        let mut p = solid(4, 4, [255, 255, 255, 255]);

7314

        let (rr, mut gc, st) = render_deps();

7315

        render_display_list_range(

7316

            &list,

7317

            &mut p,

7318

0,

7319

1,

7320

            &[(0, 1)],

7321

            0.0,

7322

            0.0,

7323

            1.0,

7324

            &rr,

7325

            &test_font_manager(),

7326

            &mut gc,

7327

            &st,

7328

7329

        .unwrap();

7330

        assert_eq!(

7331

            at(&p, 2, 2),

7332

            [255, 255, 255, 255],

7333

            "an item claimed by a child layer must not be drawn twice"

7334

);

7335

7336