Grcov report - cpurender.rs

1

//! CPU rendering for solver3 DisplayList

2

//!

3

//! This module renders a flat DisplayList (from solver3) to an AzulPixmap using agg-rust.

4

//! Unlike the old hierarchical CachedDisplayList, the new DisplayList is a simple

5

//! flat vector of rendering commands that can be executed sequentially.

6

7

use std::collections::HashMap;

8

9

use azul_core::{

10

    dom::ScrollbarOrientation,

11

    geom::{LogicalPosition, LogicalRect, LogicalSize},

12

    resources::{DecodedImage, FontInstanceKey, ImageRef, RendererResources},

13

    ui_solver::GlyphInstance,

14

};

15

use azul_css::props::basic::{pixel::DEFAULT_FONT_SIZE, ColorOrSystem, ColorU, FontRef};

16

use azul_css::props::style::filter::StyleFilter;

17

18

use agg_rust::{

19

    basics::{FillingRule, VertexSource, PATH_FLAGS_NONE},

20

    blur::stack_blur_rgba32,

21

    color::Rgba8,

22

    conv_stroke::ConvStroke,

23

    conv_transform::ConvTransform,

24

    gradient_lut::GradientLut,

25

    path_storage::PathStorage,

26

    pixfmt_rgba::{PixelFormat, PixfmtRgba32},

27

    rasterizer_scanline_aa::RasterizerScanlineAa,

28

    renderer_base::RendererBase,

29

    renderer_scanline::{render_scanlines_aa, render_scanlines_aa_solid},

30

    rendering_buffer::RowAccessor,

31

    rounded_rect::RoundedRect,

32

    scanline_u::ScanlineU8,

33

    span_allocator::SpanAllocator,

34

    span_gradient::{GradientConic, GradientFunction, GradientRadialD, GradientX, SpanGradient},

35

    span_interpolator_linear::SpanInterpolatorLinear,

36

    trans_affine::TransAffine,

37

};

38

39

use crate::{

40

    font::parsed::ParsedFont,

41

    glyph_cache::GlyphCache,

42

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

43

    text3::cache::{FontHash, FontManager},

44

};

45

46

const IDENTITY_EPSILON: f32 = 0.0001;

47

const IDENTITY_EPSILON_F64: f64 = 0.0001;

48

const MAX_SHADOW_PIXBUF_SIZE: u32 = 4096;

49

50

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

51

// Retained-Mode Compositor — Layer Tree

52

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

53

54

/// Unique identifier for a compositing layer.

55

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

56

pub struct LayerId(pub u64);

57

58

/// Persistent compositor state across frames.

59

///

60

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

61

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

62

pub struct CompositorState {

63

    /// All layers keyed by ID.

64

    pub layers: HashMap<LayerId, Layer>,

65

    /// Root layer of the tree.

66

    pub root_layer: LayerId,

67

    /// Monotonic counter for generating unique LayerIds.

68

    next_layer_id: u64,

69

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

70

    pub previous_positions: Vec<LogicalPosition>,

71

72

73

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

74

pub struct Layer {

75

    pub id: LayerId,

76

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

77

    pub pixbuf: AzulPixmap,

78

    /// Position and size in parent layer coordinates.

79

    pub bounds: LogicalRect,

80

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

81

    pub damage: Vec<LogicalRect>,

82

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

83

    pub children: Vec<LayerId>,

84

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

85

    pub scroll_offset: (f32, f32),

86

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

87

    pub opacity: f32,

88

    /// CSS filters applied at composite time.

89

    pub filters: Vec<StyleFilter>,

90

    /// CSS transform for this layer.

91

    pub transform: TransAffine,

92

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

93

    pub display_list_range: (usize, usize),

94

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

95

    pub scroll_id: Option<LocalScrollId>,

96

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

97

    pub composite_dirty: bool,

98

99

100

/// Reason a layer was created.

101

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

102

pub enum LayerReason {

103

    /// Root layer (always exists).

104

    Root,

105

    /// Created for a `PushScrollFrame`.

106

    ScrollFrame,

107

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

108

    BlurFilter,

109

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

110

    Opacity,

111

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

112

    Transform,

113

114

115

impl CompositorState {

116

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

117

88

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

118

88

        let root_id = LayerId(0);

119

88

        let root_layer = Layer::new(

120

88

            root_id,

121

88

            LogicalRect {

122

88

                origin: LogicalPosition::zero(),

123

88

                size: LogicalSize {

124

88

                    width: width as f32,

125

88

                    height: height as f32,

126

88

},

127

88

},

128

88

            width,

129

88

            height,

130

);

131

88

        let mut layers = HashMap::new();

132

88

        layers.insert(root_id, root_layer);

133

88

        CompositorState {

134

88

            layers,

135

88

            root_layer: root_id,

136

88

            next_layer_id: 1,

137

88

            previous_positions: Vec::new(),

138

88

139

88

140

141

    /// Allocate a new unique layer ID.

142

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

143

        let id = LayerId(self.next_layer_id);

144

        self.next_layer_id += 1;

145

id

146

147

148

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

149

    pub fn next_layer_id_peek(&self) -> u64 {

150

        self.next_layer_id

151

152

153

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

154

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

155

88

    pub fn allocate_layers_from_display_list(

156

88

        &mut self,

157

88

        display_list: &DisplayList,

158

88

        dpi_factor: f32,

159

88

) {

160

        // Remove all non-root layers from previous frame

161

88

        let root_id = self.root_layer;

162

88

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

163

88

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

164

88

            root.children.clear();

165

88

            root.damage.clear();

166

88

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

167

88

            root.composite_dirty = true;

168

88

169

170

88

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

171

88

        let mut i = 0;

172

173

3344

        while i < display_list.items.len() {

174

3256

            match &display_list.items[i] {

175

                DisplayListItem::PushScrollFrame {

176

                    clip_bounds,

177

                    content_size,

178

                    scroll_id,

179

..

180

                } => {

181

                    let bounds = *clip_bounds.inner();

182

                    let pw = (bounds.size.width * dpi_factor).ceil() as u32;

183

                    let ph = (bounds.size.height * dpi_factor).ceil() as u32;

184

                    if pw > 0 && ph > 0 {

185

                        let new_id = self.alloc_layer_id();

186

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

187

                        layer.scroll_id = Some(*scroll_id);

188

                        // Find the matching PopScrollFrame to set range

189

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

190

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

191

                        self.layers.insert(new_id, layer);

192

                        // Add as child of current parent

193

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

194

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

195

                            parent.children.push(new_id);

196

197

                        layer_stack.push(new_id);

198

199

200

                DisplayListItem::PopScrollFrame => {

201

                    if layer_stack.len() > 1 {

202

                        layer_stack.pop();

203

204

205

                DisplayListItem::PushOpacity { bounds, opacity } => {

206

                    if *opacity < 1.0 {

207

                        let b = *bounds.inner();

208

                        let pw = (b.size.width * dpi_factor).ceil() as u32;

209

                        let ph = (b.size.height * dpi_factor).ceil() as u32;

210

                        if pw > 0 && ph > 0 {

211

                            let new_id = self.alloc_layer_id();

212

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

213

                            layer.opacity = *opacity;

214

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

215

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

216

                            self.layers.insert(new_id, layer);

217

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

218

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

219

                                parent.children.push(new_id);

220

221

                            layer_stack.push(new_id);

222

223

224

225

                DisplayListItem::PopOpacity => {

226

                    // Only pop if the top layer was an opacity layer

227

                    if layer_stack.len() > 1 {

228

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

229

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

230

                            if layer.opacity < 1.0 && layer.scroll_id.is_none() {

231

                                layer_stack.pop();

232

233

234

235

236

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

237

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

238

                    if has_blur {

239

                        let b = *bounds.inner();

240

                        let pw = (b.size.width * dpi_factor).ceil() as u32;

241

                        let ph = (b.size.height * dpi_factor).ceil() as u32;

242

                        if pw > 0 && ph > 0 {

243

                            let new_id = self.alloc_layer_id();

244

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

245

                            layer.filters = filters.clone();

246

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

247

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

248

                            self.layers.insert(new_id, layer);

249

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

250

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

251

                                parent.children.push(new_id);

252

253

                            layer_stack.push(new_id);

254

255

256

257

                DisplayListItem::PopFilter => {

258

                    if layer_stack.len() > 1 {

259

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

260

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

261

                            if !layer.filters.is_empty() {

262

                                layer_stack.pop();

263

264

265

266

267

                DisplayListItem::PushReferenceFrame {

268

                    initial_transform,

269

                    bounds,

270

..

271

                } => {

272

                    let m = &initial_transform.m;

273

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

274

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

275

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

276

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

277

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

278

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

279

                    if !is_identity {

280

                        let b = *bounds.inner();

281

                        let pw = (b.size.width * dpi_factor).ceil().max(1.0) as u32;

282

                        let ph = (b.size.height * dpi_factor).ceil().max(1.0) as u32;

283

                        let new_id = self.alloc_layer_id();

284

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

285

                        layer.transform = TransAffine::new_custom(

286

                            m[0][0] as f64,

287

                            m[0][1] as f64,

288

                            m[1][0] as f64,

289

                            m[1][1] as f64,

290

                            m[3][0] as f64,

291

                            m[3][1] as f64,

292

);

293

                        let end =

294

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

295

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

296

                        self.layers.insert(new_id, layer);

297

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

298

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

299

                            parent.children.push(new_id);

300

301

                        layer_stack.push(new_id);

302

303

304

                DisplayListItem::PopReferenceFrame => {

305

                    if layer_stack.len() > 1 {

306

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

307

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

308

                            if !layer.transform.is_identity(IDENTITY_EPSILON_F64) {

309

                                layer_stack.pop();

310

311

312

313

314

3256

                _ => {}

315

316

3256

            i += 1;

317

318

88

319

320

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

321

    pub fn compute_damage(

322

        &mut self,

323

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

324

        old_positions: &[LogicalPosition],

325

        new_positions: &[LogicalPosition],

326

        calculated_rects: &[LogicalRect],

327

) {

328

        if dirty_nodes.is_empty() {

329

            return;

330

331

332

        let mut damage_rects = Vec::new();

333

        for &node_idx in dirty_nodes {

334

            // Old bounds

335

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

336

                let old_rect = LogicalRect {

337

                    origin: old_positions[node_idx],

338

                    size: calculated_rects[node_idx].size,

339

};

340

                damage_rects.push(old_rect);

341

342

            // New bounds

343

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

344

                let new_rect = LogicalRect {

345

                    origin: new_positions[node_idx],

346

                    size: calculated_rects[node_idx].size,

347

};

348

                damage_rects.push(new_rect);

349

350

351

352

        // Distribute damage rects to affected layers

353

        for (_, layer) in self.layers.iter_mut() {

354

            for damage in &damage_rects {

355

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

356

                    layer.damage.push(intersection);

357

                    layer.composite_dirty = true;

358

359

360

361

362

363

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

364

88

    pub fn render_layers(

365

88

        &mut self,

366

88

        display_list: &DisplayList,

367

88

        dpi_factor: f32,

368

88

        renderer_resources: &RendererResources,

369

88

        font_manager: Option<&FontManager<FontRef>>,

370

88

        glyph_cache: &mut GlyphCache,

371

88

        render_state: &CpuRenderState,

372

88

    ) -> Result<(), String> {

373

88

        let scroll_offsets = &render_state.scroll_offsets;

374

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

375

88

        let layer_ranges: Vec<(

376

88

            LayerId,

377

88

            (usize, usize),

378

88

            LogicalRect,

379

88

            Option<LocalScrollId>,

380

88

            Vec<(usize, usize)>,

381

88

        )> = self

382

88

            .layers

383

88

            .iter()

384

88

            .map(|(id, layer)| {

385

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

386

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

387

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

388

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

389

88

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

390

88

                    .children

391

88

                    .iter()

392

88

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

393

88

                    .collect();

394

88

                (*id, layer.display_list_range, layer.bounds, layer.scroll_id, child_ranges)

395

88

})

396

88

            .collect();

397

398

        #[cfg(feature = "std")]

399

88

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

400

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

401

                std::eprintln!(

402

                    "[cpu-layer] render id={:?} range={:?} bounds={:?} scroll={:?} skip={:?} (dl_len={})",

403

                    id, range, bounds, scroll_id, child_ranges, display_list.items.len()

404

);

405

406

88

407

408

176

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

409

88

            let (start, end) = *range;

410

88

            if start >= end || start >= display_list.items.len() {

411

                continue;

412

88

413

414

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

415

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

416

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

417

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

418

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

419

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

420

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

421

88

            let soff = scroll_id

422

88

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

423

88

                .unwrap_or((0.0, 0.0));

424

425

88

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

426

88

            layer.scroll_offset = soff;

427

428

            // Clear the layer pixbuf (transparent for non-root, white for root)

429

88

            if *layer_id == self.root_layer {

430

88

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

431

88

            } else {

432

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

433

434

435

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

436

88

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

437

88

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

438

88

            render_display_list_range(

439

88

                display_list,

440

88

                &mut layer.pixbuf,

441

88

                start,

442

88

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

443

88

                child_ranges,

444

88

                offset_x,

445

88

                offset_y,

446

88

                dpi_factor,

447

88

                renderer_resources,

448

88

                font_manager,

449

88

                glyph_cache,

450

88

                render_state,

451

)?;

452

453

454

88

        Ok(())

455

88

456

457

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

458

88

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

459

        // Start from root layer

460

88

        self.composite_layer_recursive(self.root_layer, output, 0.0, 0.0, dpi_factor);

461

88

462

463

88

    fn composite_layer_recursive(

464

88

        &self,

465

88

        layer_id: LayerId,

466

88

        output: &mut AzulPixmap,

467

88

        parent_offset_x: f32,

468

88

        parent_offset_y: f32,

469

88

        dpi_factor: f32,

470

88

) {

471

88

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

472

88

            Some(l) => l,

473

            None => return,

474

};

475

476

88

        let abs_x = parent_offset_x + layer.bounds.origin.x;

477

88

        let abs_y = parent_offset_y + layer.bounds.origin.y;

478

479

        // For root layer, just blit directly

480

88

        if layer_id == self.root_layer {

481

88

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

482

88

        } else {

483

            // Apply filters at composite time

484

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

485

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

486

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

487

                Some(filtered)

488

            } else {

489

                None

490

};

491

492

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

493

            let px_x = (abs_x * dpi_factor) as i32;

494

            let px_y = (abs_y * dpi_factor) as i32;

495

            blit_pixmap(src_pixbuf, output, px_x, px_y, layer.opacity);

496

497

498

        // Composite children in z-order

499

88

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

500

88

        for child_id in &children {

501

            self.composite_layer_recursive(

502

                *child_id,

503

                output,

504

                if layer_id == self.root_layer {

505

0.0

506

                } else {

507

                    abs_x

508

},

509

                if layer_id == self.root_layer {

510

0.0

511

                } else {

512

                    abs_y

513

},

514

                dpi_factor,

515

);

516

517

88

518

519

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

520

    pub fn scroll_layer(

521

        &mut self,

522

        scroll_id: LocalScrollId,

523

        new_offset: (f32, f32),

524

        display_list: &DisplayList,

525

        dpi_factor: f32,

526

        renderer_resources: &RendererResources,

527

        font_manager: Option<&FontManager<FontRef>>,

528

        glyph_cache: &mut GlyphCache,

529

    ) -> Result<(), String> {

530

        // Find the layer with this scroll_id

531

        let layer_id = self

532

            .layers

533

            .iter()

534

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

535

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

536

537

        let layer_id = match layer_id {

538

            Some(id) => id,

539

            None => return Ok(()), // No layer for this scroll ID

540

};

541

542

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

543

        let old_offset = layer.scroll_offset;

544

        let dx = new_offset.0 - old_offset.0;

545

        let dy = new_offset.1 - old_offset.1;

546

547

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

548

            return Ok(());

549

550

551

        // Shift pixels

552

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

553

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

554

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

555

556

        // Compute exposed strips and re-render them.

557

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

558

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

559

        for exposed_rect in exposed {

560

            layer.damage.push(exposed_rect);

561

562

563

        layer.scroll_offset = new_offset;

564

        layer.composite_dirty = true;

565

566

        // Re-render damaged regions

567

        let range = layer.display_list_range;

568

        let bounds = layer.bounds;

569

        let offset_x = bounds.origin.x;

570

        let offset_y = bounds.origin.y;

571

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

572

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

573

            .layers

574

            .get(&layer_id)

575

            .map(|l| {

576

                l.children

577

                    .iter()

578

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

579

                    .collect()

580

})

581

            .unwrap_or_default();

582

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

583

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

584

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

585

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

586

        render_display_list_range(

587

            display_list,

588

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

589

            range.0,

590

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

591

            &child_ranges,

592

            offset_x,

593

            offset_y,

594

            dpi_factor,

595

            renderer_resources,

596

            font_manager,

597

            glyph_cache,

598

            &empty_rs,

599

)?;

600

601

        Ok(())

602

603

604

605

impl Layer {

606

88

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

607

        Layer {

608

88

id,

609

88

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

610

                AzulPixmap {

611

                    data: vec![0; 4],

612

                    width: 1,

613

                    height: 1,

614

615

}),

616

88

            bounds,

617

88

            damage: Vec::new(),

618

88

            children: Vec::new(),

619

88

            scroll_offset: (0.0, 0.0),

620

            opacity: 1.0,

621

88

            filters: Vec::new(),

622

88

            transform: TransAffine::new(),

623

88

            display_list_range: (0, 0),

624

88

            scroll_id: None,

625

            composite_dirty: true,

626

627

88

628

629

630

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

631

// Layer helper types and functions

632

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

633

634

/// Which Push/Pop pair to match.

635

#[derive(Clone, Copy)]

636

enum MatchKind {

637

    ScrollFrame,

638

    Opacity,

639

    Filter,

640

    ReferenceFrame,

641

642

643

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

644

5

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

645

5

    let mut depth = 1u32;

646

10

    for i in (start + 1)..items.len() {

647

10

        match (&items[i], kind) {

648

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

649

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

650

5

                depth -= 1;

651

5

                if depth == 0 {

652

5

                    return i;

653

654

655

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

656

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

657

                depth -= 1;

658

                if depth == 0 {

659

                    return i;

660

661

662

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

663

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

664

                depth -= 1;

665

                if depth == 0 {

666

                    return i;

667

668

669

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

670

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

671

                depth -= 1;

672

                if depth == 0 {

673

                    return i;

674

675

676

5

            _ => {}

677

678

679

    items.len()

680

5

681

682

/// Compute the intersection of two logical rects.

683

fn rect_intersection(a: &LogicalRect, b: &LogicalRect) -> Option<LogicalRect> {

684

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

685

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

686

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

687

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

688

    if x2 > x1 && y2 > y1 {

689

        Some(LogicalRect {

690

            origin: LogicalPosition { x: x1, y: y1 },

691

            size: LogicalSize {

692

                width: x2 - x1,

693

                height: y2 - y1,

694

},

695

})

696

    } else {

697

        None

698

699

700

701

/// Blit `src` onto `dst` at pixel position (px_x, px_y) with opacity.

702

88

fn blit_pixmap(src: &AzulPixmap, dst: &mut AzulPixmap, px_x: i32, px_y: i32, opacity: f32) {

703

88

    let sw = src.width as i32;

704

88

    let sh = src.height as i32;

705

88

    let dw = dst.width as i32;

706

88

    let dh = dst.height as i32;

707

88

    let op = (opacity * 255.0).clamp(0.0, 255.0) as u32;

708

709

42240

    for sy in 0..sh {

710

42240

        let dy = px_y + sy;

711

42240

        if dy < 0 || dy >= dh {

712

            continue;

713

42240

714

27033600

        for sx in 0..sw {

715

27033600

            let dx = px_x + sx;

716

27033600

            if dx < 0 || dx >= dw {

717

                continue;

718

27033600

719

27033600

            let si = ((sy * sw + sx) * 4) as usize;

720

27033600

            let di = ((dy * dw + dx) * 4) as usize;

721

27033600

            if si + 3 >= src.data.len() || di + 3 >= dst.data.len() {

722

                continue;

723

27033600

724

725

27033600

            let sr = src.data[si] as u32;

726

27033600

            let sg = src.data[si + 1] as u32;

727

27033600

            let sb = src.data[si + 2] as u32;

728

27033600

            let sa = (src.data[si + 3] as u32 * op) / 255;

729

730

27033600

            if sa == 0 {

731

                continue;

732

27033600

733

27033600

            if sa == 255 {

734

27033600

                dst.data[di] = sr as u8;

735

27033600

                dst.data[di + 1] = sg as u8;

736

27033600

                dst.data[di + 2] = sb as u8;

737

27033600

                dst.data[di + 3] = 255;

738

27033600

            } else {

739

                let inv_sa = 255 - sa;

740

                dst.data[di] = ((sr * sa + dst.data[di] as u32 * inv_sa) / 255) as u8;

741

                dst.data[di + 1] = ((sg * sa + dst.data[di + 1] as u32 * inv_sa) / 255) as u8;

742

                dst.data[di + 2] = ((sb * sa + dst.data[di + 2] as u32 * inv_sa) / 255) as u8;

743

                dst.data[di + 3] = ((sa + dst.data[di + 3] as u32 * inv_sa / 255).min(255)) as u8;

744

745

746

747

88

748

749

/// Shift pixel data in a pixmap by (dx, dy) pixels, clearing exposed regions.

750

fn shift_pixbuf(pixmap: &mut AzulPixmap, dx: i32, dy: i32) {

751

    let w = pixmap.width as i32;

752

    let h = pixmap.height as i32;

753

    if dx.abs() >= w || dy.abs() >= h {

754

        // Entire buffer is exposed — just clear it

755

        pixmap.fill(0, 0, 0, 0);

756

        return;

757

758

759

    let stride = (w * 4) as usize;

760

    let data = &mut pixmap.data;

761

762

    // Shift rows vertically

763

    if dy > 0 {

764

        // Shift down: copy from top to bottom

765

        for row in (0..h - dy).rev() {

766

            let src_start = (row * w * 4) as usize;

767

            let dst_start = ((row + dy) * w * 4) as usize;

768

            data.copy_within(src_start..src_start + stride, dst_start);

769

770

        // Clear top rows

771

        for row in 0..dy {

772

            let start = (row * w * 4) as usize;

773

            data[start..start + stride].fill(0);

774

775

    } else if dy < 0 {

776

        let ady = (-dy) as i32;

777

        // Shift up: copy from bottom to top

778

        for row in ady..h {

779

            let src_start = (row * w * 4) as usize;

780

            let dst_start = ((row - ady) * w * 4) as usize;

781

            data.copy_within(src_start..src_start + stride, dst_start);

782

783

        // Clear bottom rows

784

        for row in (h - ady)..h {

785

            let start = (row * w * 4) as usize;

786

            data[start..start + stride].fill(0);

787

788

789

790

    // Shift columns horizontally

791

    if dx > 0 {

792

        for row in 0..h {

793

            let row_start = (row * w * 4) as usize;

794

            let shift = (dx * 4) as usize;

795

            // Shift right within the row

796

            data.copy_within(row_start..row_start + stride - shift, row_start + shift);

797

            // Clear left columns

798

            data[row_start..row_start + shift].fill(0);

799

800

    } else if dx < 0 {

801

        let adx = (-dx * 4) as usize;

802

        for row in 0..h {

803

            let row_start = (row * w * 4) as usize;

804

            data.copy_within(row_start + adx..row_start + stride, row_start);

805

            // Clear right columns

806

            data[row_start + stride - adx..row_start + stride].fill(0);

807

808

809

810

811

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

812

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

813

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

814

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

815

    let w = bounds.size.width;

816

    let h = bounds.size.height;

817

    let mut rects = Vec::new();

818

819

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

820

    if dy.abs() > 0.5 {

821

        let strip = if dy > 0.0 {

822

            // Scrolled down — top strip exposed

823

            LogicalRect {

824

                origin: LogicalPosition {

825

                    x: bounds.origin.x,

826

                    y: bounds.origin.y,

827

},

828

                size: LogicalSize {

829

                    width: w,

830

                    height: dy.min(h),

831

},

832

833

        } else {

834

            // Scrolled up — bottom strip exposed

835

            LogicalRect {

836

                origin: LogicalPosition {

837

                    x: bounds.origin.x,

838

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

839

},

840

                size: LogicalSize {

841

                    width: w,

842

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

843

},

844

845

};

846

        rects.push(strip);

847

848

849

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

850

    if dx.abs() > 0.5 {

851

        let strip = if dx > 0.0 {

852

            LogicalRect {

853

                origin: LogicalPosition {

854

                    x: bounds.origin.x,

855

                    y: bounds.origin.y,

856

},

857

                size: LogicalSize {

858

                    width: dx.min(w),

859

                    height: h,

860

},

861

862

        } else {

863

            LogicalRect {

864

                origin: LogicalPosition {

865

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

866

                    y: bounds.origin.y,

867

},

868

                size: LogicalSize {

869

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

870

                    height: h,

871

},

872

873

};

874

        rects.push(strip);

875

876

877

    rects

878

879

880

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

881

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

882

///

883

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

884

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

885

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

886

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

887

///

888

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

889

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

890

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

891

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

892

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

893

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

894

///

895

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

896

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

897

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

898

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

899

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

900

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

901

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

902

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

903

///

904

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

905

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

906

///

907

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

908

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

909

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

910

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

911

5

pub fn scroll_shift_region(

912

5

    pixmap: &mut AzulPixmap,

913

5

    clip_bounds: &LogicalRect,

914

5

    delta: (f32, f32),

915

5

    dpi_factor: f32,

916

5

) -> Vec<LogicalRect> {

917

5

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

918

5

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

919

920

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

921

5

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

922

1

        return Vec::new();

923

4

924

925

4

    let pw = pixmap.width() as i32;

926

4

    let ph = pixmap.height() as i32;

927

928

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

929

4

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

930

4

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

931

4

    let cx1 = (((clip_bounds.origin.x + clip_bounds.size.width) * dpi_factor).ceil() as i32)

932

4

        .clamp(0, pw);

933

4

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

934

4

        .clamp(0, ph);

935

4

    let region_w = cx1 - cx0;

936

4

    let region_h = cy1 - cy0;

937

4

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

938

        return Vec::new();

939

4

940

941

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

942

    // let the caller repaint the whole clip.

943

4

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

944

1

        return vec![*clip_bounds];

945

3

946

947

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

948

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

949

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

950

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

951

3

    let stride_px = pw;

952

3

    let data = pixmap.data_mut();

953

3

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

954

2

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

955

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

956

1

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

957

        (false, false) => {}

958

959

960

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

961

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

962

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

963

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

964

3

    let cb = clip_bounds;

965

3

    let mut exposed = Vec::new();

966

3

    if px_dy != 0 {

967

3

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

968

3

        let h = h_logical.min(cb.size.height);

969

3

        let y = if px_dy > 0 {

970

            // bottom strip exposed

971

3

            cb.origin.y + cb.size.height - h

972

        } else {

973

            // top strip exposed

974

            cb.origin.y

975

};

976

3

        exposed.push(LogicalRect {

977

3

            origin: LogicalPosition { x: cb.origin.x, y },

978

3

            size: LogicalSize { width: cb.size.width, height: h },

979

3

});

980

981

3

    if px_dx != 0 {

982

1

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

983

1

        let w = w_logical.min(cb.size.width);

984

1

        let x = if px_dx > 0 {

985

            // right strip exposed

986

1

            cb.origin.x + cb.size.width - w

987

        } else {

988

            // left strip exposed

989

            cb.origin.x

990

};

991

1

        exposed.push(LogicalRect {

992

1

            origin: LogicalPosition { x, y: cb.origin.y },

993

1

            size: LogicalSize { width: w, height: cb.size.height },

994

1

});

995

2

996

3

    exposed

997

5

998

999

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

1000

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

1001

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

1002

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

1003

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

1004

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

1005

1006

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

1007

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

1008

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

1009

#[inline]

1010

2

fn shift_vertical_1d(

1011

2

    data: &mut [u8],

1012

2

    stride_px: i32,

1013

2

    cx0: i32,

1014

2

    cy0: i32,

1015

2

    cx1: i32,

1016

2

    cy1: i32,

1017

2

    px_dy: i32,

1018

2

) {

1019

2

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

1020

240

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

1021

2

    if px_dy > 0 {

1022

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

1023

120

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

1024

120

            let s = row_off(dst + px_dy);

1025

120

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

1026

120

1027

    } else {

1028

        let amt = -px_dy;

1029

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

1030

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

1031

            let s = row_off(dst - amt);

1032

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

1033

1034

1035

2

1036

1037

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

1038

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

1039

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

1040

#[inline]

1041

fn shift_horizontal_1d(

1042

    data: &mut [u8],

1043

    stride_px: i32,

1044

    cx0: i32,

1045

    cy0: i32,

1046

    cx1: i32,

1047

    cy1: i32,

1048

    px_dx: i32,

1049

) {

1050

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

1051

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

1052

    if px_dx > 0 {

1053

        let shift = (px_dx * 4) as usize;

1054

        for row in cy0..cy1 {

1055

            let left = row_off(row);

1056

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

1057

1058

    } else {

1059

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

1060

        for row in cy0..cy1 {

1061

            let left = row_off(row);

1062

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

1063

1064

1065

1066

1067

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

1068

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

1069

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

1070

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

1071

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

1072

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

1073

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

1074

#[inline]

1075

1

fn shift_diagonal_2d(

1076

1

    data: &mut [u8],

1077

1

    stride_px: i32,

1078

1

    cx0: i32,

1079

1

    cy0: i32,

1080

1

    cx1: i32,

1081

1

    cy1: i32,

1082

1

    px_dx: i32,

1083

1

    px_dy: i32,

1084

1

) {

1085

1

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

1086

1

    if span_cols <= 0 {

1087

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

1088

1

1089

1

    let len = (span_cols * 4) as usize;

1090

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

1091

1

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

1092

1

        (cx0 + px_dx, cx0)

1093

    } else {

1094

        (cx0, cx0 - px_dx)

1095

};

1096

70

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

1097

70

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

1098

1

    if px_dy > 0 {

1099

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

1100

70

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

1101

70

            let s = src_byte(dst + px_dy);

1102

70

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

1103

70

1104

    } else {

1105

        let amt = -px_dy;

1106

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

1107

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

1108

            let s = src_byte(dst - amt);

1109

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

1110

1111

1112

1

1113

1114

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

1115

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

1116

///

1117

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

1118

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

1119

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

1120

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

1121

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

1122

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

1123

///

1124

/// `scroll_offset` is the frame's current offset, used to project the content's

1125

/// opaque fills (stored at content coords) into viewport space for the coverage

1126

/// test. A scroll frame over nothing-but-the-clear-color is always eligible (no

1127

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

1128

5

pub fn scroll_fast_path_eligible(

1129

5

    display_list: &DisplayList,

1130

5

    scroll_id: LocalScrollId,

1131

5

    clip_bounds: &LogicalRect,

1132

5

    scroll_offset: (f32, f32),

1133

5

) -> bool {

1134

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

1135

10

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

1136

5

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

1137

10

});

1138

5

    let start = match start {

1139

5

        Some(s) => s,

1140

        None => return true, // no frame for this id → nothing to shift

1141

};

1142

5

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

1143

5

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

1144

1145

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

1146

    // into viewport space by the scroll offset). Then nothing behind can ever

1147

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

1148

5

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

1149

5

        .iter()

1150

5

        .filter_map(|it| opaque_fill_rect(it))

1151

5

        .map(|r| LogicalRect {

1152

1

            origin: LogicalPosition {

1153

1

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

1154

1

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

1155

1

},

1156

1

            size: r.size,

1157

1

})

1158

5

        .collect();

1159

5

    if rect_covered_by(clip_bounds, &content_opaque) {

1160

1

        return true;

1161

4

1162

1163

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

1164

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

1165

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

1166

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

1167

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

1168

    //   - flat opaque Rect  → track its colour

1169

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

1170

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

1171

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

1172

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

1173

4

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

1174

4

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

1175

4

    let mut backdrop_color: Option<ColorU> = None;

1176

4

    for it in display_list.items[..start].iter() {

1177

4

        if it.is_state_management() {

1178

            continue;

1179

4

1180

4

        let b = match it.bounds() {

1181

4

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

1182

            _ => continue,

1183

};

1184

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

1185

4

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

1186

4

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

1187

4

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

1188

4

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

1189

4

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

1190

4

        if isect_area < clip_area * 0.10 {

1191

            continue; // negligible — thin border / small decoration

1192

4

1193

4

        match it {

1194

4

            DisplayListItem::Rect { color, border_radius, .. }

1195

4

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

1196

1197

1

                match backdrop_color {

1198

3

                    None => backdrop_color = Some(*color),

1199

1

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

1200

1

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

1201

1202

3

                backdrop_fills.push(b);

1203

1204

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

1205

            DisplayListItem::Image { .. }

1206

            | DisplayListItem::LinearGradient { .. }

1207

            | DisplayListItem::RadialGradient { .. }

1208

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

1209

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

1210

1211

1212

3

    if backdrop_fills.is_empty() {

1213

1

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

1214

2

1215

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

1216

    // against the clear would drag visibly).

1217

2

    rect_covered_by(clip_bounds, &backdrop_fills)

1218

5

1219

1220

/// If `it` is a fully-opaque, square-cornered rectangle fill, its bounds.

1221

5

fn opaque_fill_rect(it: &DisplayListItem) -> Option<LogicalRect> {

1222

5

    match it {

1223

        DisplayListItem::Rect {

1224

5

            bounds,

1225

5

            color,

1226

5

            border_radius,

1227

5

        } if color.a == 255 && border_radius.is_zero() => Some(*bounds.inner()),

1228

4

        _ => None,

1229

1230

5

1231

1232

/// True if every ~4px sample of `target` lies inside some rect in `covers`.

1233

/// Point-sampled so sub-4px gaps (imperceptible if dragged) don't force a full

1234

/// repaint; empty `covers` → not covered.

1235

11

fn rect_covered_by(target: &LogicalRect, covers: &[LogicalRect]) -> bool {

1236

11

    if covers.is_empty() {

1237

5

        return false;

1238

6

1239

6

    let step = 4.0_f32;

1240

6

    let x0 = target.origin.x;

1241

6

    let y0 = target.origin.y;

1242

6

    let x1 = x0 + target.size.width;

1243

6

    let y1 = y0 + target.size.height;

1244

6

    let mut y = y0 + step * 0.5;

1245

126

    while y < y1 {

1246

122

        let mut x = x0 + step * 0.5;

1247

3122

        while x < x1 {

1248

3328

            let inside = covers.iter().any(|r| {

1249

3328

                x >= r.origin.x

1250

3328

                    && x < r.origin.x + r.size.width

1251

3328

                    && y >= r.origin.y

1252

3327

                    && y < r.origin.y + r.size.height

1253

3328

});

1254

3002

            if !inside {

1255

2

                return false;

1256

3000

1257

3000

            x += step;

1258

1259

120

        y += step;

1260

1261

4

    true

1262

11

1263

1264

/// Apply CSS filters to a pixbuf at composite time.

1265

fn apply_layer_filters(pixmap: &mut AzulPixmap, filters: &[StyleFilter], dpi_factor: f32) {

1266

    for filter in filters {

1267

        match filter {

1268

            StyleFilter::Blur(blur) => {

1269

                let rx = blur

1270

                    .width

1271

                    .to_pixels_internal(0.0, DEFAULT_FONT_SIZE, DEFAULT_FONT_SIZE)

1272

                    * dpi_factor;

1273

                let ry = blur

1274

                    .height

1275

                    .to_pixels_internal(0.0, DEFAULT_FONT_SIZE, DEFAULT_FONT_SIZE)

1276

                    * dpi_factor;

1277

                let radius = ((rx + ry) / 2.0).ceil() as u32;

1278

                if radius > 0 {

1279

                    let w = pixmap.width;

1280

                    let h = pixmap.height;

1281

                    let stride = (w * 4) as i32;

1282

                    let mut ra = unsafe {

1283

                        RowAccessor::new_with_buf(pixmap.data.as_mut_ptr(), w, h, stride)

1284

};

1285

                    stack_blur_rgba32(&mut ra, radius, radius);

1286

1287

1288

            StyleFilter::Opacity(pct) => {

1289

                let op = (pct.normalized() * 255.0).clamp(0.0, 255.0) as u32;

1290

                for chunk in pixmap.data.chunks_exact_mut(4) {

1291

                    chunk[3] = ((chunk[3] as u32 * op) / 255) as u8;

1292

1293

1294

            StyleFilter::Grayscale(pct) => {

1295

                let amount = pct.normalized().clamp(0.0, 1.0);

1296

                for chunk in pixmap.data.chunks_exact_mut(4) {

1297

                    let r = chunk[0] as f32;

1298

                    let g = chunk[1] as f32;

1299

                    let b = chunk[2] as f32;

1300

                    let gray = 0.2126 * r + 0.7152 * g + 0.0722 * b;

1301

                    chunk[0] = (r + (gray - r) * amount).clamp(0.0, 255.0) as u8;

1302

                    chunk[1] = (g + (gray - g) * amount).clamp(0.0, 255.0) as u8;

1303

                    chunk[2] = (b + (gray - b) * amount).clamp(0.0, 255.0) as u8;

1304

1305

1306

            StyleFilter::Brightness(pct) => {

1307

                let factor = pct.normalized().max(0.0);

1308

                for chunk in pixmap.data.chunks_exact_mut(4) {

1309

                    chunk[0] = (chunk[0] as f32 * factor).clamp(0.0, 255.0) as u8;

1310

                    chunk[1] = (chunk[1] as f32 * factor).clamp(0.0, 255.0) as u8;

1311

                    chunk[2] = (chunk[2] as f32 * factor).clamp(0.0, 255.0) as u8;

1312

1313

1314

            StyleFilter::Contrast(pct) => {

1315

                let factor = pct.normalized().max(0.0);

1316

                for chunk in pixmap.data.chunks_exact_mut(4) {

1317

                    chunk[0] = ((((chunk[0] as f32 / 255.0) - 0.5) * factor + 0.5) * 255.0)

1318

                        .clamp(0.0, 255.0) as u8;

1319

                    chunk[1] = ((((chunk[1] as f32 / 255.0) - 0.5) * factor + 0.5) * 255.0)

1320

                        .clamp(0.0, 255.0) as u8;

1321

                    chunk[2] = ((((chunk[2] as f32 / 255.0) - 0.5) * factor + 0.5) * 255.0)

1322

                        .clamp(0.0, 255.0) as u8;

1323

1324

1325

            StyleFilter::Invert(pct) => {

1326

                let amount = pct.normalized().clamp(0.0, 1.0);

1327

                for chunk in pixmap.data.chunks_exact_mut(4) {

1328

                    chunk[0] = (chunk[0] as f32 + (255.0 - 2.0 * chunk[0] as f32) * amount)

1329

                        .clamp(0.0, 255.0) as u8;

1330

                    chunk[1] = (chunk[1] as f32 + (255.0 - 2.0 * chunk[1] as f32) * amount)

1331

                        .clamp(0.0, 255.0) as u8;

1332

                    chunk[2] = (chunk[2] as f32 + (255.0 - 2.0 * chunk[2] as f32) * amount)

1333

                        .clamp(0.0, 255.0) as u8;

1334

1335

1336

            StyleFilter::Sepia(pct) => {

1337

                let amount = pct.normalized().clamp(0.0, 1.0);

1338

                for chunk in pixmap.data.chunks_exact_mut(4) {

1339

                    let r = chunk[0] as f32;

1340

                    let g = chunk[1] as f32;

1341

                    let b = chunk[2] as f32;

1342

                    let sr = (0.393 * r + 0.769 * g + 0.189 * b).min(255.0);

1343

                    let sg = (0.349 * r + 0.686 * g + 0.168 * b).min(255.0);

1344

                    let sb = (0.272 * r + 0.534 * g + 0.131 * b).min(255.0);

1345

                    chunk[0] = (r + (sr - r) * amount).clamp(0.0, 255.0) as u8;

1346

                    chunk[1] = (g + (sg - g) * amount).clamp(0.0, 255.0) as u8;

1347

                    chunk[2] = (b + (sb - b) * amount).clamp(0.0, 255.0) as u8;

1348

1349

1350

            StyleFilter::Saturate(pct) => {

1351

                let s = pct.normalized().max(0.0);

1352

                for chunk in pixmap.data.chunks_exact_mut(4) {

1353

                    let r = chunk[0] as f32;

1354

                    let g = chunk[1] as f32;

1355

                    let b = chunk[2] as f32;

1356

                    let gray = 0.2126 * r + 0.7152 * g + 0.0722 * b;

1357

                    chunk[0] = (gray + (r - gray) * s).clamp(0.0, 255.0) as u8;

1358

                    chunk[1] = (gray + (g - gray) * s).clamp(0.0, 255.0) as u8;

1359

                    chunk[2] = (gray + (b - gray) * s).clamp(0.0, 255.0) as u8;

1360

1361

1362

            StyleFilter::HueRotate(angle) => {

1363

                let rad = angle.to_degrees().to_radians();

1364

                let cos_a = rad.cos();

1365

                let sin_a = rad.sin();

1366

                for chunk in pixmap.data.chunks_exact_mut(4) {

1367

                    let r = chunk[0] as f32;

1368

                    let g = chunk[1] as f32;

1369

                    let b = chunk[2] as f32;

1370

                    let nr = (0.213 + 0.787 * cos_a - 0.213 * sin_a) * r

1371

                        + (0.715 - 0.715 * cos_a - 0.715 * sin_a) * g

1372

                        + (0.072 - 0.072 * cos_a + 0.928 * sin_a) * b;

1373

                    let ng = (0.213 - 0.213 * cos_a + 0.143 * sin_a) * r

1374

                        + (0.715 + 0.285 * cos_a + 0.140 * sin_a) * g

1375

                        + (0.072 - 0.072 * cos_a - 0.283 * sin_a) * b;

1376

                    let nb = (0.213 - 0.213 * cos_a - 0.787 * sin_a) * r

1377

                        + (0.715 - 0.715 * cos_a + 0.715 * sin_a) * g

1378

                        + (0.072 + 0.928 * cos_a + 0.072 * sin_a) * b;

1379

                    chunk[0] = nr.clamp(0.0, 255.0) as u8;

1380

                    chunk[1] = ng.clamp(0.0, 255.0) as u8;

1381

                    chunk[2] = nb.clamp(0.0, 255.0) as u8;

1382

1383

1384

            _ => {} // Blend, Flood, ColorMatrix, DropShadow, ComponentTransfer, Offset, Composite not yet implemented

1385

1386

1387

1388

1389

/// Render a range of display list items into a layer pixbuf,

1390

/// offsetting coordinates by the layer's origin.

1391

88

fn render_display_list_range(

1392

88

    display_list: &DisplayList,

1393

88

    pixmap: &mut AzulPixmap,

1394

88

    start: usize,

1395

88

    end: usize,

1396

88

    // Index ranges (start..end) that belong to CHILD layers (nested scroll

1397

88

    // frames / opacity / transform groups). Those items render into the child's

1398

88

    // OWN pixbuf, so they must be skipped here — otherwise they're drawn twice

1399

88

    // (once in this layer at absolute coords AND once in the child layer),

1400

88

    // which produced overlapping / ghosted text in overflow:scroll content.

1401

88

    skip_ranges: &[(usize, usize)],

1402

88

    offset_x: f32,

1403

88

    offset_y: f32,

1404

88

    dpi_factor: f32,

1405

88

    renderer_resources: &RendererResources,

1406

88

    font_manager: Option<&FontManager<FontRef>>,

1407

88

    glyph_cache: &mut GlyphCache,

1408

88

    render_state: &CpuRenderState,

1409

88

) -> Result<(), String> {

1410

88

    let mut transform_stack = vec![TransAffine::new()];

1411

88

    let mut clip_stack: Vec<Option<AzRect>> = vec![None];

1412

88

    let mut mask_stack: Vec<MaskEntry> = Vec::new();

1413

    // Apply the layer origin offset: content is translated by -(offset_x,offset_y)

1414

    // so it's rendered RELATIVE to this layer's pixbuf origin (which is then

1415

    // composited back at +layer_origin). The renderer translates positions by

1416

    // `pos - scroll_offset`, so seeding the scroll-offset stack with the layer

1417

    // origin achieves the relative placement. Previously offset_x/offset_y were

1418

    // ignored, so child layers were double-offset (content drawn at absolute

1419

    // coords then composited at +origin) — text fell to the bottom of the box.

1420

88

    let mut scroll_offset_stack: Vec<(f32, f32)> = vec![(offset_x, offset_y)];

1421

1422

3256

    for i in start..end {

1423

        // Skip items rendered by a child layer (see skip_ranges doc above).

1424

3256

        if skip_ranges.iter().any(|(s, e)| i >= *s && i < *e) {

1425

            continue;

1426

3256

1427

3256

        let item = &display_list.items[i];

1428

3256

        render_single_item(

1429

3256

            item,

1430

3256

            pixmap,

1431

3256

            dpi_factor,

1432

3256

            renderer_resources,

1433

3256

            font_manager,

1434

3256

            glyph_cache,

1435

3256

            &mut transform_stack,

1436

3256

            &mut clip_stack,

1437

3256

            &mut mask_stack,

1438

3256

            &mut scroll_offset_stack,

1439

3256

            render_state,

1440

)?;

1441

1442

1443

88

    Ok(())

1444

88

1445

1446

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

1447

// AzulPixmap — replacement for tiny_skia::Pixmap

1448

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

1449

1450

/// A simple RGBA pixel buffer. Replaces tiny_skia::Pixmap.

1451

pub struct AzulPixmap {

1452

    data: Vec<u8>,

1453

    width: u32,

1454

    height: u32,

1455

1456

1457

impl AzulPixmap {

1458

    /// Create a new pixmap filled with opaque white.

1459

2293

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

1460

2293

        if width == 0 || height == 0 {

1461

            return None;

1462

2293

1463

2293

        let len = (width as usize) * (height as usize) * 4;

1464

2293

        let data = vec![255u8; len]; // opaque white

1465

2293

        Some(Self {

1466

2293

            data,

1467

2293

            width,

1468

2293

            height,

1469

2293

})

1470

2293

1471

1472

    /// Fill the entire pixmap with a single color.

1473

2200

    pub fn fill(&mut self, r: u8, g: u8, b: u8, a: u8) {

1474

186665776

        for chunk in self.data.chunks_exact_mut(4) {

1475

186665776

            chunk[0] = r;

1476

186665776

            chunk[1] = g;

1477

186665776

            chunk[2] = b;

1478

186665776

            chunk[3] = a;

1479

186665776

1480

2200

1481

1482

    /// Fill a rectangular region with a single color (pixel coordinates).

1483

44

    pub fn fill_rect(&mut self, x: i32, y: i32, w: i32, h: i32, r: u8, g: u8, b: u8, a: u8) {

1484

44

        let pw = self.width as i32;

1485

44

        let ph = self.height as i32;

1486

44

        let x0 = x.max(0).min(pw);

1487

44

        let y0 = y.max(0).min(ph);

1488

        // saturating: a non-finite/huge layout size casts to i32::MAX, and `x + w`

1489

        // would then overflow (debug panic). Clamp instead.

1490

44

        let x1 = x.saturating_add(w).max(0).min(pw);

1491

44

        let y1 = y.saturating_add(h).max(0).min(ph);

1492

17688

        for row in y0..y1 {

1493

17688

            let start = (row * pw + x0) as usize * 4;

1494

17688

            let end = (row * pw + x1) as usize * 4;

1495

17688

            if end <= self.data.len() {

1496

11037312

                for chunk in self.data[start..end].chunks_exact_mut(4) {

1497

11037312

                    chunk[0] = r;

1498

11037312

                    chunk[1] = g;

1499

11037312

                    chunk[2] = b;

1500

11037312

                    chunk[3] = a;

1501

11037312

1502

1503

1504

44

1505

1506

    /// Raw RGBA pixel data.

1507

1946

    pub fn data(&self) -> &[u8] {

1508

1946

        &self.data

1509

1946

1510

1511

    /// Mutable raw RGBA pixel data.

1512

8

    pub fn data_mut(&mut self) -> &mut [u8] {

1513

8

        &mut self.data

1514

8

1515

1516

    /// Width in pixels.

1517

1290

    pub fn width(&self) -> u32 {

1518

1290

        self.width

1519

1290

1520

1521

    /// Height in pixels.

1522

1280

    pub fn height(&self) -> u32 {

1523

1280

        self.height

1524

1280

1525

1526

    /// Create a clone of this pixmap (for filter application).

1527

352

    pub fn clone_pixmap(&self) -> Self {

1528

352

        Self {

1529

352

            data: self.data.clone(),

1530

352

            width: self.width,

1531

352

            height: self.height,

1532

352

1533

352

1534

1535

    /// Resize the pixmap preserving existing content in the top-left corner.

1536

    /// New right/bottom strips are filled with the specified color.

1537

    /// Only grows — returns None if new dimensions are smaller (caller should realloc).

1538

    pub fn resize_grow_only(

1539

        &mut self,

1540

        new_width: u32,

1541

        new_height: u32,

1542

        fill_r: u8,

1543

        fill_g: u8,

1544

        fill_b: u8,

1545

        fill_a: u8,

1546

    ) -> Option<()> {

1547

        if new_width < self.width || new_height < self.height {

1548

            return None;

1549

1550

        if new_width == self.width && new_height == self.height {

1551

            return Some(());

1552

1553

1554

        let old_w = self.width as usize;

1555

        let old_h = self.height as usize;

1556

        let new_w = new_width as usize;

1557

        let new_h = new_height as usize;

1558

        let mut new_data = vec![fill_a; new_w * new_h * 4];

1559

1560

        // Fill entire buffer with fill color first (covers right + bottom strips)

1561

        for chunk in new_data.chunks_exact_mut(4) {

1562

            chunk[0] = fill_r;

1563

            chunk[1] = fill_g;

1564

            chunk[2] = fill_b;

1565

            chunk[3] = fill_a;

1566

1567

1568

        // Copy old rows into top-left corner

1569

        let old_stride = old_w * 4;

1570

        let new_stride = new_w * 4;

1571

        for row in 0..old_h {

1572

            let src = row * old_stride;

1573

            let dst = row * new_stride;

1574

            new_data[dst..dst + old_stride].copy_from_slice(&self.data[src..src + old_stride]);

1575

1576

1577

        self.data = new_data;

1578

        self.width = new_width;

1579

        self.height = new_height;

1580

        Some(())

1581

1582

1583

    /// Resize the pixmap, reusing existing content for the overlapping region.

1584

    /// Works for both growing and shrinking. New areas are filled with the given color.

1585

    pub fn resize_reuse(

1586

        &mut self,

1587

        new_width: u32,

1588

        new_height: u32,

1589

        fill_r: u8,

1590

        fill_g: u8,

1591

        fill_b: u8,

1592

        fill_a: u8,

1593

) {

1594

        if new_width == self.width && new_height == self.height {

1595

            return;

1596

1597

1598

        let old_w = self.width as usize;

1599

        let old_h = self.height as usize;

1600

        let new_w = new_width as usize;

1601

        let new_h = new_height as usize;

1602

        let new_stride = new_w * 4;

1603

        let old_stride = old_w * 4;

1604

1605

        let mut new_data = vec![0u8; new_w * new_h * 4];

1606

1607

        // Fill entire buffer with fill color

1608

        for chunk in new_data.chunks_exact_mut(4) {

1609

            chunk[0] = fill_r;

1610

            chunk[1] = fill_g;

1611

            chunk[2] = fill_b;

1612

            chunk[3] = fill_a;

1613

1614

1615

        // Copy overlapping region from old to new

1616

        let copy_rows = old_h.min(new_h);

1617

        let copy_cols_bytes = old_stride.min(new_stride);

1618

        for row in 0..copy_rows {

1619

            let src = row * old_stride;

1620

            let dst = row * new_stride;

1621

            new_data[dst..dst + copy_cols_bytes]

1622

                .copy_from_slice(&self.data[src..src + copy_cols_bytes]);

1623

1624

1625

        self.data = new_data;

1626

        self.width = new_width;

1627

        self.height = new_height;

1628

1629

1630

    /// Encode to PNG using the `png` crate.

1631

1584

    pub fn encode_png(&self) -> Result<Vec<u8>, String> {

1632

1584

        let mut buf = Vec::new();

1633

1634

1584

            let mut encoder = png::Encoder::new(&mut buf, self.width, self.height);

1635

1584

            encoder.set_color(png::ColorType::Rgba);

1636

1584

            encoder.set_depth(png::BitDepth::Eight);

1637

1584

            let mut writer = encoder

1638

1584

                .write_header()

1639

1584

                .map_err(|e| format!("PNG header error: {}", e))?;

1640

1584

            writer

1641

1584

                .write_image_data(&self.data)

1642

1584

                .map_err(|e| format!("PNG write error: {}", e))?;

1643

1644

1584

        Ok(buf)

1645

1584

1646

1647

    /// Decode a PNG byte slice into an AzulPixmap.

1648

924

    pub fn decode_png(png_bytes: &[u8]) -> Result<Self, String> {

1649

924

        let decoder = png::Decoder::new(std::io::Cursor::new(png_bytes));

1650

924

        let mut reader = decoder

1651

924

            .read_info()

1652

924

            .map_err(|e| format!("PNG decode error: {}", e))?;

1653

924

        let buf_size = reader

1654

924

            .output_buffer_size()

1655

924

            .ok_or_else(|| "PNG: unknown output buffer size".to_string())?;

1656

924

        let mut buf = vec![0u8; buf_size];

1657

924

        let info = reader

1658

924

            .next_frame(&mut buf)

1659

924

            .map_err(|e| format!("PNG frame error: {}", e))?;

1660

924

        let width = info.width;

1661

924

        let height = info.height;

1662

1663

        // Convert to RGBA if needed

1664

924

        let data = match info.color_type {

1665

924

            png::ColorType::Rgba => buf[..info.buffer_size()].to_vec(),

1666

            png::ColorType::Rgb => {

1667

                let mut rgba = Vec::with_capacity((width * height * 4) as usize);

1668

                for chunk in buf[..info.buffer_size()].chunks_exact(3) {

1669

                    rgba.push(chunk[0]);

1670

                    rgba.push(chunk[1]);

1671

                    rgba.push(chunk[2]);

1672

                    rgba.push(255);

1673

1674

                rgba

1675

1676

            png::ColorType::Grayscale => {

1677

                let mut rgba = Vec::with_capacity((width * height * 4) as usize);

1678

                for &v in &buf[..info.buffer_size()] {

1679

                    rgba.push(v);

1680

                    rgba.push(v);

1681

                    rgba.push(v);

1682

                    rgba.push(255);

1683

1684

                rgba

1685

1686

            other => return Err(format!("Unsupported PNG color type: {:?}", other)),

1687

};

1688

1689

924

        Ok(Self {

1690

924

            data,

1691

924

            width,

1692

924

            height,

1693

924

})

1694

924

1695

1696

1697

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

1698

// Pixel-diff comparison for regression testing

1699

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

1700

1701

/// Result of comparing two pixmaps pixel-by-pixel.

1702

#[derive(Debug, Clone)]

1703

pub struct PixelDiffResult {

1704

    /// Number of pixels that differ beyond the threshold.

1705

    pub diff_count: u64,

1706

    /// Total number of pixels compared.

1707

    pub total_pixels: u64,

1708

    /// Maximum per-channel delta found across all pixels.

1709

    pub max_delta: u8,

1710

    /// Whether dimensions matched.

1711

    pub dimensions_match: bool,

1712

    /// Width of the reference image.

1713

    pub ref_width: u32,

1714

    /// Height of the reference image.

1715

    pub ref_height: u32,

1716

    /// Width of the test image.

1717

    pub test_width: u32,

1718

    /// Height of the test image.

1719

    pub test_height: u32,

1720

1721

1722

impl PixelDiffResult {

1723

    /// True if the images are identical within tolerance.

1724

    pub fn is_match(&self) -> bool {

1725

        self.dimensions_match && self.diff_count == 0

1726

1727

1728

    /// Fraction of pixels that differ (0.0 = identical, 1.0 = all different).

1729

    pub fn diff_ratio(&self) -> f64 {

1730

        if self.total_pixels == 0 {

1731

0.0

1732

        } else {

1733

            self.diff_count as f64 / self.total_pixels as f64

1734

1735

1736

1737

1738

/// Compare two pixmaps pixel-by-pixel with a per-channel tolerance.

1739

///

1740

/// `threshold` is the maximum allowed per-channel difference (0 = exact match,

1741

/// 2-3 = anti-aliasing tolerance, 10+ = loose match).

1742

396

pub fn pixel_diff(reference: &AzulPixmap, test: &AzulPixmap, threshold: u8) -> PixelDiffResult {

1743

396

    let dimensions_match = reference.width == test.width && reference.height == test.height;

1744

396

    if !dimensions_match {

1745

        return PixelDiffResult {

1746

            diff_count: 0,

1747

            total_pixels: 0,

1748

            max_delta: 0,

1749

            dimensions_match: false,

1750

            ref_width: reference.width,

1751

            ref_height: reference.height,

1752

            test_width: test.width,

1753

            test_height: test.height,

1754

};

1755

396

1756

1757

396

    let total_pixels = (reference.width as u64) * (reference.height as u64);

1758

396

    let mut diff_count = 0u64;

1759

396

    let mut max_delta = 0u8;

1760

1761

9785600

    for (ref_chunk, test_chunk) in reference

1762

396

        .data

1763

396

        .chunks_exact(4)

1764

396

        .zip(test.data.chunks_exact(4))

1765

1766

9785600

        let mut pixel_differs = false;

1767

48928000

        for c in 0..4 {

1768

39142400

            let delta = (ref_chunk[c] as i16 - test_chunk[c] as i16).unsigned_abs() as u8;

1769

39142400

            if delta > threshold {

1770

                pixel_differs = true;

1771

39142400

1772

39142400

            if delta > max_delta {

1773

                max_delta = delta;

1774

39142400

1775

1776

9785600

        if pixel_differs {

1777

            diff_count += 1;

1778

9785600

1779

1780

1781

396

    PixelDiffResult {

1782

396

        diff_count,

1783

396

        total_pixels,

1784

396

        max_delta,

1785

396

        dimensions_match: true,

1786

396

        ref_width: reference.width,

1787

396

        ref_height: reference.height,

1788

396

        test_width: test.width,

1789

396

        test_height: test.height,

1790

396

1791

396

1792

1793

/// Compare a rendered pixmap against a reference PNG file.

1794

///

1795

/// Returns `Ok(result)` with the diff stats, or `Err` if the reference

1796

/// file cannot be read/decoded.

1797

pub fn compare_against_reference(

1798

    rendered: &AzulPixmap,

1799

    reference_png_path: &str,

1800

    threshold: u8,

1801

) -> Result<PixelDiffResult, String> {

1802

    let ref_bytes = std::fs::read(reference_png_path)

1803

        .map_err(|e| format!("Cannot read reference image {}: {}", reference_png_path, e))?;

1804

    let reference = AzulPixmap::decode_png(&ref_bytes)?;

1805

    Ok(pixel_diff(&reference, rendered, threshold))

1806

1807

1808

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

1809

// Simple rect type (replaces tiny_skia::Rect)

1810

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

1811

1812

#[derive(Debug, Clone, Copy)]

1813

struct AzRect {

1814

    x: f32,

1815

    y: f32,

1816

    width: f32,

1817

    height: f32,

1818

1819

1820

/// Intersect a freshly-pushed clip with the currently-active one. `None`

1821

/// means "no clip". An EMPTY intersection clips everything (zero-area rect) —

1822

/// it must NOT degrade to `None`/unclipped, or nested clips could escape

1823

/// their parents.

1824

396

fn intersect_clips(current: Option<AzRect>, new: Option<AzRect>) -> Option<AzRect> {

1825

396

    match (current, new) {

1826

308

        (Some(cur), Some(new)) => {

1827

308

            let x0 = cur.x.max(new.x);

1828

308

            let y0 = cur.y.max(new.y);

1829

308

            let x1 = (cur.x + cur.width).min(new.x + new.width);

1830

308

            let y1 = (cur.y + cur.height).min(new.y + new.height);

1831

308

            Some(AzRect {

1832

308

                x: x0,

1833

308

                y: y0,

1834

308

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

1835

308

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

1836

308

})

1837

1838

        (Some(cur), None) => Some(cur),

1839

88

        (None, new) => new,

1840

1841

396

1842

1843

impl AzRect {

1844

13904

    fn from_xywh(x: f32, y: f32, w: f32, h: f32) -> Option<Self> {

1845

13904

        if w <= 0.0

1846

13904

            || h <= 0.0

1847

13904

            || !x.is_finite()

1848

13904

            || !y.is_finite()

1849

13904

            || !w.is_finite()

1850

13904

            || !h.is_finite()

1851

1852

            return None;

1853

13904

1854

13904

        Some(Self {

1855

13904

x,

1856

13904

y,

1857

13904

            width: w,

1858

13904

            height: h,

1859

13904

})

1860

13904

1861

1862

    /// Intersect this rect with a clip rect. Returns None if fully clipped.

1863

5412

    fn clip(&self, clip: &AzRect) -> Option<AzRect> {

1864

5412

        let x1 = self.x.max(clip.x);

1865

5412

        let y1 = self.y.max(clip.y);

1866

5412

        let x2 = (self.x + self.width).min(clip.x + clip.width);

1867

5412

        let y2 = (self.y + self.height).min(clip.y + clip.height);

1868

5412

        if x2 > x1 && y2 > y1 {

1869

880

            Some(AzRect {

1870

880

                x: x1,

1871

880

                y: y1,

1872

880

                width: x2 - x1,

1873

880

                height: y2 - y1,

1874

880

})

1875

        } else {

1876

4532

            None

1877

1878

5412

1879

1880

1881

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

1882

// AGG helper: fill a PathStorage with a solid color into an AzulPixmap

1883

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

1884

1885

13772

fn agg_fill_path(

1886

13772

    pixmap: &mut AzulPixmap,

1887

13772

    path: &mut dyn VertexSource,

1888

13772

    color: &Rgba8,

1889

13772

    rule: FillingRule,

1890

13772

) {

1891

13772

    agg_fill_path_clipped(pixmap, path, color, rule, None);

1892

13772

1893

1894

/// Fill a path with an optional pixel-level clip box.

1895

///

1896

/// When `clip` is `Some`, `RendererBase::clip_box_i()` restricts all

1897

/// scanline output to the clip region.  This handles scroll-frame clips,

1898

/// border-radius is TODO (would need a mask), transforms are handled by

1899

/// transforming the clip box through the inverse transform before setting it.

1900

14168

fn agg_fill_path_clipped(

1901

14168

    pixmap: &mut AzulPixmap,

1902

14168

    path: &mut dyn VertexSource,

1903

14168

    color: &Rgba8,

1904

14168

    rule: FillingRule,

1905

14168

    clip: Option<AzRect>,

1906

14168

) {

1907

14168

    let w = pixmap.width;

1908

14168

    let h = pixmap.height;

1909

14168

    let stride = (w * 4) as i32;

1910

14168

    let mut ra = unsafe { RowAccessor::new_with_buf(pixmap.data.as_mut_ptr(), w, h, stride) };

1911

14168

    let mut pf = PixfmtRgba32::new(&mut ra);

1912

14168

    let mut rb = RendererBase::new(pf);

1913

14168

    if let Some(c) = clip {

1914

        rb.clip_box_i(

1915

            c.x as i32,

1916

            c.y as i32,

1917

            (c.x + c.width) as i32 - 1,

1918

            (c.y + c.height) as i32 - 1,

1919

);

1920

14168

1921

14168

    let mut ras = RasterizerScanlineAa::new();

1922

14168

    ras.filling_rule(rule);

1923

14168

    ras.add_path(path, 0);

1924

14168

    let mut sl = ScanlineU8::new();

1925

14168

    render_scanlines_aa_solid(&mut ras, &mut sl, &mut rb, color);

1926

14168

1927

1928

fn agg_fill_transformed_path(

1929

    pixmap: &mut AzulPixmap,

1930

    path: &mut PathStorage,

1931

    color: &Rgba8,

1932

    rule: FillingRule,

1933

    transform: &TransAffine,

1934

) {

1935

    agg_fill_transformed_path_clipped(pixmap, path, color, rule, transform, None);

1936

1937

1938

fn agg_fill_transformed_path_clipped(

1939

    pixmap: &mut AzulPixmap,

1940

    path: &mut PathStorage,

1941

    color: &Rgba8,

1942

    rule: FillingRule,

1943

    transform: &TransAffine,

1944

    clip: Option<AzRect>,

1945

) {

1946

    if transform.is_identity(IDENTITY_EPSILON_F64) {

1947

        agg_fill_path_clipped(pixmap, path, color, rule, clip);

1948

    } else {

1949

        let mut transformed = ConvTransform::new(path, transform.clone());

1950

        agg_fill_path_clipped(pixmap, &mut transformed, color, rule, clip);

1951

1952

1953

1954

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

1955

// AGG helper: fill a path with a gradient into an AzulPixmap

1956

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

1957

1958

fn agg_fill_gradient<G: GradientFunction>(

1959

    pixmap: &mut AzulPixmap,

1960

    path: &mut dyn VertexSource,

1961

    lut: &GradientLut,

1962

    gradient_fn: G,

1963

    transform: TransAffine,

1964

    d1: f64,

1965

    d2: f64,

1966

) {

1967

    agg_fill_gradient_clipped(pixmap, path, lut, gradient_fn, transform, d1, d2, None);

1968

1969

1970

44

fn agg_fill_gradient_clipped<G: GradientFunction>(

1971

44

    pixmap: &mut AzulPixmap,

1972

44

    path: &mut dyn VertexSource,

1973

44

    lut: &GradientLut,

1974

44

    gradient_fn: G,

1975

44

    transform: TransAffine,

1976

44

    d1: f64,

1977

44

    d2: f64,

1978

44

    clip: Option<AzRect>,

1979

44

) {

1980

44

    let w = pixmap.width;

1981

44

    let h = pixmap.height;

1982

44

    let stride = (w * 4) as i32;

1983

44

    let mut ra = unsafe { RowAccessor::new_with_buf(pixmap.data.as_mut_ptr(), w, h, stride) };

1984

44

    let mut pf = PixfmtRgba32::new(&mut ra);

1985

44

    let mut rb = RendererBase::new(pf);

1986

44

    if let Some(c) = clip {

1987

        rb.clip_box_i(

1988

            c.x as i32,

1989

            c.y as i32,

1990

            (c.x + c.width) as i32 - 1,

1991

            (c.y + c.height) as i32 - 1,

1992

);

1993

44

1994

44

    let mut ras = RasterizerScanlineAa::new();

1995

44

    ras.filling_rule(FillingRule::NonZero);

1996

44

    ras.add_path(path, 0);

1997

44

    let mut sl = ScanlineU8::new();

1998

1999

44

    let interp = SpanInterpolatorLinear::new(transform);

2000

44

    let mut sg = SpanGradient::new(interp, gradient_fn, lut, d1, d2);

2001

44

    let mut alloc = SpanAllocator::<Rgba8>::new();

2002

44

    render_scanlines_aa(&mut ras, &mut sl, &mut rb, &mut alloc, &mut sg);

2003

44

2004

2005

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

2006

// Gradient helpers

2007

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

2008

2009

/// Fallback color used when a `system:*` keyword cannot be resolved

2010

/// (for example because no `SystemStyle` is attached to the

2011

/// [`CpuRenderState`], or because the requested key is unset on the

2012

/// current platform). CSS Images Level 4 leaves the color undefined in

2013

/// this case; transparent black means the stop simply contributes

2014

/// nothing to the gradient instead of poisoning it with an arbitrary

2015

/// visible color (the previous behaviour was hardcoded mid-gray, which

2016

/// produced visibly wrong output).

2017

const SYSTEM_COLOR_FALLBACK: ColorU = ColorU {

2018

    r: 0,

2019

    g: 0,

2020

    b: 0,

2021

    a: 0,

2022

};

2023

2024

/// Resolve a `ColorOrSystem` against the optional system palette.

2025

///

2026

/// Concrete colors are returned verbatim. `system:*` keywords are

2027

/// resolved against `system_colors` when available and fall back to

2028

/// `SYSTEM_COLOR_FALLBACK` otherwise.

2029

88

fn resolve_color(

2030

88

    color: &ColorOrSystem,

2031

88

    system_colors: Option<&azul_css::system::SystemColors>,

2032

88

) -> ColorU {

2033

88

    match (color, system_colors) {

2034

88

        (ColorOrSystem::Color(c), _) => *c,

2035

        (ColorOrSystem::System(_), Some(sc)) => color.resolve(sc, SYSTEM_COLOR_FALLBACK),

2036

        (ColorOrSystem::System(_), None) => SYSTEM_COLOR_FALLBACK,

2037

2038

88

2039

2040

/// Build a GradientLut from normalized linear color stops.

2041

44

fn build_gradient_lut_linear(

2042

44

    stops: &azul_css::props::style::background::NormalizedLinearColorStopVec,

2043

44

    system_colors: Option<&azul_css::system::SystemColors>,

2044

44

) -> GradientLut {

2045

44

    let mut lut = GradientLut::new_default();

2046

44

    let stops_slice = stops.as_ref();

2047

44

    if stops_slice.len() < 2 {

2048

        // Need at least 2 stops; fill with transparent

2049

        lut.add_color(0.0, Rgba8::new(0, 0, 0, 0));

2050

        lut.add_color(1.0, Rgba8::new(0, 0, 0, 0));

2051

        lut.build_lut();

2052

        return lut;

2053

44

2054

132

    for stop in stops_slice {

2055

88

        let offset = stop.offset.normalized() as f64; // 0.0..1.0

2056

88

        let c = resolve_color(&stop.color, system_colors);

2057

88

        lut.add_color(

2058

88

            offset,

2059

88

            Rgba8::new(c.r as u32, c.g as u32, c.b as u32, c.a as u32),

2060

88

);

2061

88

2062

44

    lut.build_lut();

2063

44

lut

2064

44

2065

2066

/// Build a GradientLut from normalized radial (conic) color stops.

2067

fn build_gradient_lut_radial(

2068

    stops: &azul_css::props::style::background::NormalizedRadialColorStopVec,

2069

    system_colors: Option<&azul_css::system::SystemColors>,

2070

) -> GradientLut {

2071

    let mut lut = GradientLut::new_default();

2072

    let stops_slice = stops.as_ref();

2073

    if stops_slice.len() < 2 {

2074

        lut.add_color(0.0, Rgba8::new(0, 0, 0, 0));

2075

        lut.add_color(1.0, Rgba8::new(0, 0, 0, 0));

2076

        lut.build_lut();

2077

        return lut;

2078

2079

    for stop in stops_slice {

2080

        // Conic stops use angle — normalize to 0..1 fraction of full circle

2081

        let offset = (stop.angle.to_degrees() / 360.0).clamp(0.0, 1.0) as f64;

2082

        let c = resolve_color(&stop.color, system_colors);

2083

        lut.add_color(

2084

            offset,

2085

            Rgba8::new(c.r as u32, c.g as u32, c.b as u32, c.a as u32),

2086

);

2087

2088

    lut.build_lut();

2089

lut

2090

2091

2092

/// Resolve a background position to (x_fraction, y_fraction) in 0..1 range.

2093

fn resolve_background_position(

2094

    pos: &azul_css::props::style::background::StyleBackgroundPosition,

2095

    width: f32,

2096

    height: f32,

2097

) -> (f32, f32) {

2098

    use azul_css::props::style::background::{

2099

        BackgroundPositionHorizontal, BackgroundPositionVertical,

2100

};

2101

2102

    let x = match pos.horizontal {

2103

        BackgroundPositionHorizontal::Left => 0.0,

2104

        BackgroundPositionHorizontal::Center => 0.5,

2105

        BackgroundPositionHorizontal::Right => 1.0,

2106

        BackgroundPositionHorizontal::Exact(px) => {

2107

            let val = px.to_pixels_internal(width, 16.0, 16.0);

2108

            if width > 0.0 {

2109

                val / width

2110

            } else {

2111

0.5

2112

2113

2114

};

2115

    let y = match pos.vertical {

2116

        BackgroundPositionVertical::Top => 0.0,

2117

        BackgroundPositionVertical::Center => 0.5,

2118

        BackgroundPositionVertical::Bottom => 1.0,

2119

        BackgroundPositionVertical::Exact(px) => {

2120

            let val = px.to_pixels_internal(height, 16.0, 16.0);

2121

            if height > 0.0 {

2122

                val / height

2123

            } else {

2124

0.5

2125

2126

2127

};

2128

    (x, y)

2129

2130

2131

44

fn render_linear_gradient(

2132

44

    pixmap: &mut AzulPixmap,

2133

44

    bounds: &LogicalRect,

2134

44

    gradient: &azul_css::props::style::background::LinearGradient,

2135

44

    border_radius: &BorderRadius,

2136

44

    clip: Option<AzRect>,

2137

44

    dpi_factor: f32,

2138

44

    system_colors: Option<&azul_css::system::SystemColors>,

2139

44

) -> Result<(), String> {

2140

    use azul_css::props::basic::geometry::{LayoutRect, LayoutSize};

2141

2142

44

    let rect = match logical_rect_to_az_rect(bounds, dpi_factor) {

2143

44

        Some(r) => r,

2144

        None => return Ok(()),

2145

};

2146

2147

44

    let stops = gradient.stops.as_ref();

2148

44

    if stops.is_empty() {

2149

        return Ok(());

2150

44

2151

2152

44

    let lut = build_gradient_lut_linear(&gradient.stops, system_colors);

2153

2154

    // Convert Direction to start/end points using the existing to_points method

2155

44

    let layout_rect = LayoutRect {

2156

44

        origin: azul_css::props::basic::geometry::LayoutPoint::new(0, 0),

2157

44

        size: LayoutSize {

2158

44

            width: (rect.width as isize),

2159

44

            height: (rect.height as isize),

2160

44

},

2161

44

};

2162

44

    let (from_pt, to_pt) = gradient.direction.to_points(&layout_rect);

2163

2164

    // Pixel-space start/end

2165

44

    let x1 = rect.x as f64 + from_pt.x as f64;

2166

44

    let y1 = rect.y as f64 + from_pt.y as f64;

2167

44

    let x2 = rect.x as f64 + to_pt.x as f64;

2168

44

    let y2 = rect.y as f64 + to_pt.y as f64;

2169

2170

44

    let dx = x2 - x1;

2171

44

    let dy = y2 - y1;

2172

44

    let len = (dx * dx + dy * dy).sqrt();

2173

44

    if len < 0.001 {

2174

        return Ok(());

2175

44

2176

2177

    // gradient-space (0..100, 0) → pixel-space line (x1,y1)→(x2,y2). Use agg's

2178

    // helper so the composition order is T * R * S — hand-rolling it via

2179

    // new_translation().rotate().scale() pre-multiplies and ends up as

2180

    // S * R * T, which rotates the translation and yields out-of-range gx.

2181

44

    let mut transform = TransAffine::new_line_segment(x1, y1, x2, y2, 100.0);

2182

44

    transform.invert();

2183

2184

44

    let mut path = if border_radius.is_zero() {

2185

44

        build_rect_path(&rect)

2186

    } else {

2187

        build_rounded_rect_path(&rect, border_radius, dpi_factor)

2188

};

2189

2190

44

    agg_fill_gradient_clipped(

2191

44

        pixmap, &mut path, &lut, GradientX, transform, 0.0, 100.0, clip,

2192

);

2193

44

    Ok(())

2194

44

2195

2196

fn render_radial_gradient(

2197

    pixmap: &mut AzulPixmap,

2198

    bounds: &LogicalRect,

2199

    gradient: &azul_css::props::style::background::RadialGradient,

2200

    border_radius: &BorderRadius,

2201

    clip: Option<AzRect>,

2202

    dpi_factor: f32,

2203

    system_colors: Option<&azul_css::system::SystemColors>,

2204

) -> Result<(), String> {

2205

    use azul_css::props::style::background::{RadialGradientSize, Shape};

2206

2207

    let rect = match logical_rect_to_az_rect(bounds, dpi_factor) {

2208

        Some(r) => r,

2209

        None => return Ok(()),

2210

};

2211

2212

    let stops = gradient.stops.as_ref();

2213

    if stops.is_empty() {

2214

        return Ok(());

2215

2216

2217

    let lut = build_gradient_lut_linear(&gradient.stops, system_colors);

2218

2219

    let w = rect.width as f64;

2220

    let h = rect.height as f64;

2221

2222

    // Compute center from position

2223

    let (cx_frac, cy_frac) =

2224

        resolve_background_position(&gradient.position, rect.width, rect.height);

2225

    let cx = rect.x as f64 + cx_frac as f64 * w;

2226

    let cy = rect.y as f64 + cy_frac as f64 * h;

2227

2228

    // Compute radius based on shape and size

2229

    let radius = match gradient.size {

2230

        RadialGradientSize::ClosestSide => {

2231

            let dx = (cx_frac as f64 * w).min((1.0 - cx_frac as f64) * w);

2232

            let dy = (cy_frac as f64 * h).min((1.0 - cy_frac as f64) * h);

2233

            match gradient.shape {

2234

                Shape::Circle => dx.min(dy),

2235

                Shape::Ellipse => dx.min(dy), // simplified

2236

2237

2238

        RadialGradientSize::FarthestSide => {

2239

            let dx = (cx_frac as f64 * w).max((1.0 - cx_frac as f64) * w);

2240

            let dy = (cy_frac as f64 * h).max((1.0 - cy_frac as f64) * h);

2241

            match gradient.shape {

2242

                Shape::Circle => dx.max(dy),

2243

                Shape::Ellipse => dx.max(dy),

2244

2245

2246

        RadialGradientSize::ClosestCorner => {

2247

            let dx = (cx_frac as f64 * w).min((1.0 - cx_frac as f64) * w);

2248

            let dy = (cy_frac as f64 * h).min((1.0 - cy_frac as f64) * h);

2249

            (dx * dx + dy * dy).sqrt()

2250

2251

        RadialGradientSize::FarthestCorner => {

2252

            let dx = (cx_frac as f64 * w).max((1.0 - cx_frac as f64) * w);

2253

            let dy = (cy_frac as f64 * h).max((1.0 - cy_frac as f64) * h);

2254

            (dx * dx + dy * dy).sqrt()

2255

2256

};

2257

2258

    if radius < 0.001 {

2259

        return Ok(());

2260

2261

2262

    // Gradient-space (radius=100 at distance=100) → pixel-space around (cx, cy).

2263

    // Build as T * S (scale first, then translate) so S only affects the radius.

2264

    // scale() pre-multiplies so we must start from scaling matrix.

2265

    let mut transform = TransAffine::new_scaling_uniform(radius / 100.0);

2266

    transform.translate(cx, cy);

2267

    transform.invert();

2268

2269

    let mut path = if border_radius.is_zero() {

2270

        build_rect_path(&rect)

2271

    } else {

2272

        build_rounded_rect_path(&rect, border_radius, dpi_factor)

2273

};

2274

2275

    agg_fill_gradient_clipped(

2276

        pixmap,

2277

        &mut path,

2278

        &lut,

2279

        GradientRadialD,

2280

        transform,

2281

        0.0,

2282

        100.0,

2283

        clip,

2284

);

2285

    Ok(())

2286

2287

2288

fn render_conic_gradient(

2289

    pixmap: &mut AzulPixmap,

2290

    bounds: &LogicalRect,

2291

    gradient: &azul_css::props::style::background::ConicGradient,

2292

    border_radius: &BorderRadius,

2293

    clip: Option<AzRect>,

2294

    dpi_factor: f32,

2295

    system_colors: Option<&azul_css::system::SystemColors>,

2296

) -> Result<(), String> {

2297

    let rect = match logical_rect_to_az_rect(bounds, dpi_factor) {

2298

        Some(r) => r,

2299

        None => return Ok(()),

2300

};

2301

2302

    let stops = gradient.stops.as_ref();

2303

    if stops.is_empty() {

2304

        return Ok(());

2305

2306

2307

    let lut = build_gradient_lut_radial(&gradient.stops, system_colors);

2308

2309

    let w = rect.width as f64;

2310

    let h = rect.height as f64;

2311

2312

    // Compute center

2313

    let (cx_frac, cy_frac) = resolve_background_position(&gradient.center, rect.width, rect.height);

2314

    let cx = rect.x as f64 + cx_frac as f64 * w;

2315

    let cy = rect.y as f64 + cy_frac as f64 * h;

2316

2317

    // Start angle (CSS conic gradients start at 12 o'clock = -90deg in math coords)

2318

    let start_angle_deg = gradient.angle.to_degrees();

2319

    let start_angle_rad = ((start_angle_deg - 90.0) as f64).to_radians();

2320

2321

    // Forward: gradient angle θ → pixel rotated by start_angle around (cx, cy).

2322

    // Build as T * R so rotation is applied before translation (rotate() pre-multiplies,

2323

    // so start from rotation matrix and translate last).

2324

    let mut transform = TransAffine::new_rotation(start_angle_rad);

2325

    transform.translate(cx, cy);

2326

    transform.invert();

2327

2328

    // GradientConic maps atan2(y,x) * d / pi, covering [0, d] for the half-circle.

2329

    // We use d2 = 100 as the range; the LUT maps 0..1 over that.

2330

    let d2 = 100.0;

2331

2332

    let mut path = if border_radius.is_zero() {

2333

        build_rect_path(&rect)

2334

    } else {

2335

        build_rounded_rect_path(&rect, border_radius, dpi_factor)

2336

};

2337

2338

    agg_fill_gradient_clipped(

2339

        pixmap,

2340

        &mut path,

2341

        &lut,

2342

        GradientConic,

2343

        transform,

2344

        0.0,

2345

d2,

2346

        clip,

2347

);

2348

    Ok(())

2349

2350

2351

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

2352

// Box shadow rendering

2353

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

2354

2355

176

fn render_box_shadow(

2356

176

    pixmap: &mut AzulPixmap,

2357

176

    bounds: &LogicalRect,

2358

176

    shadow: &azul_css::props::style::box_shadow::StyleBoxShadow,

2359

176

    border_radius: &BorderRadius,

2360

176

    dpi_factor: f32,

2361

176

) -> Result<(), String> {

2362

    use azul_css::props::style::box_shadow::BoxShadowClipMode;

2363

2364

176

    let rect = match logical_rect_to_az_rect(bounds, dpi_factor) {

2365

176

        Some(r) => r,

2366

        None => return Ok(()),

2367

};

2368

2369

176

    let offset_x =

2370

176

        shadow

2371

176

            .offset_x

2372

176

            .inner

2373

176

            .to_pixels_internal(0.0, DEFAULT_FONT_SIZE, DEFAULT_FONT_SIZE)

2374

176

            * dpi_factor;

2375

176

    let offset_y =

2376

176

        shadow

2377

176

            .offset_y

2378

176

            .inner

2379

176

            .to_pixels_internal(0.0, DEFAULT_FONT_SIZE, DEFAULT_FONT_SIZE)

2380

176

            * dpi_factor;

2381

176

    let blur_r =

2382

176

        (shadow

2383

176

            .blur_radius

2384

176

            .inner

2385

176

            .to_pixels_internal(0.0, DEFAULT_FONT_SIZE, DEFAULT_FONT_SIZE)

2386

176

            * dpi_factor)

2387

176

            .max(0.0);

2388

176

    let spread =

2389

176

        shadow

2390

176

            .spread_radius

2391

176

            .inner

2392

176

            .to_pixels_internal(0.0, DEFAULT_FONT_SIZE, DEFAULT_FONT_SIZE)

2393

176

            * dpi_factor;

2394

2395

176

    let color = shadow.color;

2396

176

    if color.a == 0 {

2397

        return Ok(());

2398

176

2399

2400

    // Compute shadow rect (expanded by spread, padded by blur)

2401

176

    let padding = blur_r.ceil();

2402

176

    let shadow_x = rect.x + offset_x - spread - padding;

2403

176

    let shadow_y = rect.y + offset_y - spread - padding;

2404

176

    let shadow_w = rect.width + 2.0 * spread + 2.0 * padding;

2405

176

    let shadow_h = rect.height + 2.0 * spread + 2.0 * padding;

2406

2407

176

    if shadow_w <= 0.0 || shadow_h <= 0.0 {

2408

        return Ok(());

2409

176

2410

2411

176

    let sw = shadow_w.ceil() as u32;

2412

176

    let sh = shadow_h.ceil() as u32;

2413

2414

176

    if sw == 0 || sh == 0 || sw > MAX_SHADOW_PIXBUF_SIZE || sh > MAX_SHADOW_PIXBUF_SIZE {

2415

        return Ok(());

2416

176

2417

2418

    // Create temp buffer and draw the shadow shape into it

2419

176

    let mut tmp = AzulPixmap::new(sw, sh).ok_or("cannot create shadow pixmap")?;

2420

176

    tmp.fill(0, 0, 0, 0); // transparent

2421

2422

    // The shape origin within the temp buffer

2423

176

    let shape_x = padding + spread;

2424

176

    let shape_y = padding + spread;

2425

176

    let shape_rect = match AzRect::from_xywh(shape_x, shape_y, rect.width, rect.height) {

2426

176

        Some(r) => r,

2427

        None => return Ok(()),

2428

};

2429

2430

176

    let agg_color = Rgba8::new(

2431

176

        color.r as u32,

2432

176

        color.g as u32,

2433

176

        color.b as u32,

2434

176

        color.a as u32,

2435

);

2436

176

    if border_radius.is_zero() {

2437

176

        let mut path = build_rect_path(&shape_rect);

2438

176

        agg_fill_path(&mut tmp, &mut path, &agg_color, FillingRule::NonZero);

2439

176

    } else {

2440

        let mut path = build_rounded_rect_path(&shape_rect, border_radius, dpi_factor);

2441

        agg_fill_path(&mut tmp, &mut path, &agg_color, FillingRule::NonZero);

2442

2443

2444

    // Apply blur

2445

176

    if blur_r > 0.5 {

2446

176

        let blur_radius = (blur_r.ceil() as u32).min(254);

2447

176

        let stride = (sw * 4) as i32;

2448

176

        let mut ra = unsafe { RowAccessor::new_with_buf(tmp.data.as_mut_ptr(), sw, sh, stride) };

2449

176

        stack_blur_rgba32(&mut ra, blur_radius, blur_radius);

2450

176

2451

2452

    // Blit the shadow buffer onto the main pixmap

2453

176

    let dst_x = shadow_x as i32;

2454

176

    let dst_y = shadow_y as i32;

2455

176

    blit_buffer(pixmap, &tmp.data, sw, sh, dst_x, dst_y);

2456

2457

176

    Ok(())

2458

176

2459

2460

/// Alpha-blend one premultiplied-alpha RGBA buffer onto another at (dx, dy).

2461

176

fn blit_buffer(dst: &mut AzulPixmap, src: &[u8], src_w: u32, src_h: u32, dx: i32, dy: i32) {

2462

176

    let dw = dst.width as i32;

2463

176

    let dh = dst.height as i32;

2464

2465

13376

    for py in 0..src_h as i32 {

2466

13376

        let ty = dy + py;

2467

13376

        if ty < 0 || ty >= dh {

2468

            continue;

2469

13376

2470

1016576

        for px in 0..src_w as i32 {

2471

1016576

            let tx = dx + px;

2472

1016576

            if tx < 0 || tx >= dw {

2473

                continue;

2474

1016576

2475

2476

1016576

            let si = ((py as u32 * src_w + px as u32) * 4) as usize;

2477

1016576

            let di = ((ty as u32 * dst.width + tx as u32) * 4) as usize;

2478

2479

1016576

            if si + 3 >= src.len() || di + 3 >= dst.data.len() {

2480

                continue;

2481

1016576

2482

2483

1016576

            let sa = src[si + 3] as u32;

2484

1016576

            if sa == 0 {

2485

22528

                continue;

2486

994048

2487

994048

            if sa == 255 {

2488

                dst.data[di] = src[si];

2489

                dst.data[di + 1] = src[si + 1];

2490

                dst.data[di + 2] = src[si + 2];

2491

                dst.data[di + 3] = 255;

2492

994048

            } else {

2493

994048

                // Premultiplied-alpha compositing: src RGB already premultiplied by AGG

2494

994048

                let inv_sa = 255 - sa;

2495

994048

                dst.data[di] =

2496

994048

                    ((src[si] as u32 + dst.data[di] as u32 * inv_sa / 255).min(255)) as u8;

2497

994048

                dst.data[di + 1] =

2498

994048

                    ((src[si + 1] as u32 + dst.data[di + 1] as u32 * inv_sa / 255).min(255)) as u8;

2499

994048

                dst.data[di + 2] =

2500

994048

                    ((src[si + 2] as u32 + dst.data[di + 2] as u32 * inv_sa / 255).min(255)) as u8;

2501

994048

                dst.data[di + 3] = ((sa + dst.data[di + 3] as u32 * inv_sa / 255).min(255)) as u8;

2502

994048

2503

2504

2505

176

2506

2507

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

2508

// Image mask clipping

2509

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

2510

2511

/// Entry on the mask/opacity stack.

2512

enum MaskEntry {

2513

    /// Image mask clip (R8 mask).

2514

    ImageMask {

2515

        snapshot: Vec<u8>,

2516

        mask_data: Vec<u8>,

2517

        origin_x: i32,

2518

        origin_y: i32,

2519

        width: u32,

2520

        height: u32,

2521

},

2522

    /// Opacity layer.

2523

    Opacity {

2524

        snapshot: Vec<u8>,

2525

        rect: AzRect,

2526

        opacity: f32,

2527

},

2528

2529

2530

/// Take a snapshot of a rectangular region of the pixmap.

2531

220

fn snapshot_region(pixmap: &AzulPixmap, x: i32, y: i32, w: u32, h: u32) -> Vec<u8> {

2532

220

    let pw = pixmap.width as i32;

2533

220

    let ph = pixmap.height as i32;

2534

220

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

2535

2536

22000

    for py in 0..h as i32 {

2537

22000

        let sy = y + py;

2538

22000

        if sy < 0 || sy >= ph {

2539

            continue;

2540

22000

2541

2640000

        for px in 0..w as i32 {

2542

2640000

            let sx = x + px;

2543

2640000

            if sx < 0 || sx >= pw {

2544

                continue;

2545

2640000

2546

2640000

            let si = ((sy as u32 * pixmap.width + sx as u32) * 4) as usize;

2547

2640000

            let di = ((py as u32 * w + px as u32) * 4) as usize;

2548

2640000

            if si + 3 < pixmap.data.len() && di + 3 < snap.len() {

2549

2640000

                snap[di] = pixmap.data[si];

2550

2640000

                snap[di + 1] = pixmap.data[si + 1];

2551

2640000

                snap[di + 2] = pixmap.data[si + 2];

2552

2640000

                snap[di + 3] = pixmap.data[si + 3];

2553

2640000

2554

2555

2556

220

    snap

2557

220

2558

2559

/// Extract and scale mask image data (R8) to target dimensions.

2560

220

fn extract_mask_data(mask_image: &ImageRef, target_w: u32, target_h: u32) -> Option<Vec<u8>> {

2561

220

    let image_data = mask_image.get_data();

2562

220

    let (mask_bytes, src_w, src_h) = match &*image_data {

2563

220

        DecodedImage::Raw((descriptor, data)) => {

2564

220

            let w = descriptor.width as u32;

2565

220

            let h = descriptor.height as u32;

2566

220

            if w == 0 || h == 0 {

2567

                return None;

2568

220

2569

220

            let bytes = match data {

2570

220

                azul_core::resources::ImageData::Raw(shared) => shared.as_ref(),

2571

                _ => return None,

2572

};

2573

220

            match descriptor.format {

2574

220

                azul_core::resources::RawImageFormat::R8 => (bytes.to_vec(), w, h),

2575

                azul_core::resources::RawImageFormat::BGRA8 => {

2576

                    // Use alpha channel as mask

2577

                    let mut r8 = Vec::with_capacity((w * h) as usize);

2578

                    for chunk in bytes.chunks_exact(4) {

2579

                        r8.push(chunk[3]); // alpha

2580

2581

                    (r8, w, h)

2582

2583

                _ => {

2584

                    // Use first channel as grayscale mask

2585

                    let chan_count = bytes.len() / (w * h) as usize;

2586

                    if chan_count == 0 {

2587

                        return None;

2588

2589

                    let mut r8 = Vec::with_capacity((w * h) as usize);

2590

                    for i in 0..(w * h) as usize {

2591

                        r8.push(bytes[i * chan_count]);

2592

2593

                    (r8, w, h)

2594

2595

2596

2597

        _ => return None,

2598

};

2599

2600

220

    if target_w == 0 || target_h == 0 {

2601

        return None;

2602

220

2603

2604

    // Scale mask to target dimensions via nearest-neighbor

2605

220

    let mut scaled = vec![0u8; (target_w * target_h) as usize];

2606

220

    let sx = src_w as f32 / target_w as f32;

2607

220

    let sy = src_h as f32 / target_h as f32;

2608

22000

    for py in 0..target_h {

2609

2640000

        for px in 0..target_w {

2610

2640000

            let mx = ((px as f32 * sx) as u32).min(src_w - 1);

2611

2640000

            let my = ((py as f32 * sy) as u32).min(src_h - 1);

2612

2640000

            scaled[(py * target_w + px) as usize] = mask_bytes[(my * src_w + mx) as usize];

2613

2640000

2614

2615

220

    Some(scaled)

2616

220

2617

2618

/// Apply a mask: for each pixel in the mask region, blend between the snapshot

2619

/// (pre-mask state) and the current pixmap state using the mask value.

2620

220

fn apply_mask(pixmap: &mut AzulPixmap, entry: &MaskEntry) {

2621

220

    let (snapshot, mask_data, origin_x, origin_y, width, height) = match entry {

2622

        MaskEntry::ImageMask {

2623

220

            snapshot,

2624

220

            mask_data,

2625

220

            origin_x,

2626

220

            origin_y,

2627

220

            width,

2628

220

            height,

2629

220

        } => (

2630

220

            snapshot,

2631

220

            mask_data.as_slice(),

2632

220

            *origin_x,

2633

220

            *origin_y,

2634

220

            *width,

2635

220

            *height,

2636

220

),

2637

        _ => return,

2638

};

2639

2640

220

    let pw = pixmap.width as i32;

2641

220

    let ph = pixmap.height as i32;

2642

2643

22000

    for py in 0..height as i32 {

2644

22000

        let dy = origin_y + py;

2645

22000

        if dy < 0 || dy >= ph {

2646

            continue;

2647

22000

2648

2640000

        for px in 0..width as i32 {

2649

2640000

            let dx = origin_x + px;

2650

2640000

            if dx < 0 || dx >= pw {

2651

                continue;

2652

2640000

2653

2654

2640000

            let mi = (py as u32 * width + px as u32) as usize;

2655

2640000

            let mask_val = mask_data.get(mi).copied().unwrap_or(0) as u32;

2656

2657

2640000

            let pi = ((dy as u32 * pixmap.width + dx as u32) * 4) as usize;

2658

2640000

            let si = ((py as u32 * width + px as u32) * 4) as usize;

2659

2660

2640000

            if pi + 3 >= pixmap.data.len() || si + 3 >= snapshot.len() {

2661

                continue;

2662

2640000

2663

2664

            // Blend: result = snapshot * (255 - mask) + current * mask

2665

            // mask_val 255 = fully visible (keep current), 0 = fully clipped (restore snapshot)

2666

2640000

            let inv_mask = 255 - mask_val;

2667

13200000

            for c in 0..4 {

2668

10560000

                let snap_c = snapshot[si + c] as u32;

2669

10560000

                let cur_c = pixmap.data[pi + c] as u32;

2670

10560000

                pixmap.data[pi + c] = ((cur_c * mask_val + snap_c * inv_mask) / 255) as u8;

2671

10560000

2672

2673

2674

220

2675

2676

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

2677

// Public API

2678

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

2679

2680

pub struct RenderOptions {

2681

    pub width: f32,

2682

    pub height: f32,

2683

    pub dpi_factor: f32,

2684

2685

2686

/// Reuse `retained` pixmap if it matches the target dimensions, otherwise allocate new.

2687

1100

fn acquire_pixmap(retained: Option<AzulPixmap>, w: u32, h: u32) -> Result<AzulPixmap, String> {

2688

1100

    if let Some(p) = retained {

2689

        if p.width == w && p.height == h {

2690

            return Ok(p);

2691

2692

1100

2693

1100

    AzulPixmap::new(w, h).ok_or_else(|| "cannot create pixmap".to_string())

2694

1100

2695

2696

pub fn render(

2697

    dl: &DisplayList,

2698

    res: &RendererResources,

2699

    opts: RenderOptions,

2700

    glyph_cache: &mut GlyphCache,

2701

) -> Result<AzulPixmap, String> {

2702

    let RenderOptions {

2703

        width,

2704

        height,

2705

        dpi_factor,

2706

    } = opts;

2707

2708

    let mut pixmap = acquire_pixmap(

2709

        None,

2710

        (width * dpi_factor) as u32,

2711

        (height * dpi_factor) as u32,

2712

)?;

2713

    pixmap.fill(255, 255, 255, 255);

2714

2715

    render_display_list(dl, &mut pixmap, dpi_factor, res, None, glyph_cache)?;

2716

2717

    Ok(pixmap)

2718

2719

2720

/// Render a display list using fonts from FontManager directly.

2721

/// This is used in reftest scenarios where RendererResources doesn't have fonts registered.

2722

1100

pub fn render_with_font_manager(

2723

1100

    dl: &DisplayList,

2724

1100

    res: &RendererResources,

2725

1100

    font_manager: &FontManager<FontRef>,

2726

1100

    opts: RenderOptions,

2727

1100

    glyph_cache: &mut GlyphCache,

2728

1100

) -> Result<AzulPixmap, String> {

2729

1100

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

2730

1100

    render_with_font_manager_and_scroll(dl, res, font_manager, opts, glyph_cache, &empty_state)

2731

1100

2732

2733

/// Render with FontManager and explicit render state (scroll offsets + GPU values).

2734

/// Used by `take_screenshot` to render with the current scroll/transform/opacity state.

2735

1100

pub fn render_with_font_manager_and_scroll(

2736

1100

    dl: &DisplayList,

2737

1100

    res: &RendererResources,

2738

1100

    font_manager: &FontManager<FontRef>,

2739

1100

    opts: RenderOptions,

2740

1100

    glyph_cache: &mut GlyphCache,

2741

1100

    render_state: &CpuRenderState,

2742

1100

) -> Result<AzulPixmap, String> {

2743

1100

    render_with_font_manager_and_scroll_retained(

2744

1100

dl,

2745

1100

        res,

2746

1100

        font_manager,

2747

1100

        opts,

2748

1100

        glyph_cache,

2749

1100

        render_state,

2750

1100

        None,

2751

2752

1100

2753

2754

/// Render with optional retained pixmap. If `retained` is Some and matches

2755

/// the target dimensions, it is reused (cleared to white) instead of

2756

/// allocating a fresh buffer. The pixmap is returned regardless.

2757

1100

pub fn render_with_font_manager_and_scroll_retained(

2758

1100

    dl: &DisplayList,

2759

1100

    res: &RendererResources,

2760

1100

    font_manager: &FontManager<FontRef>,

2761

1100

    opts: RenderOptions,

2762

1100

    glyph_cache: &mut GlyphCache,

2763

1100

    render_state: &CpuRenderState,

2764

1100

    retained: Option<AzulPixmap>,

2765

1100

) -> Result<AzulPixmap, String> {

2766

    let RenderOptions {

2767

1100

        width,

2768

1100

        height,

2769

1100

        dpi_factor,

2770

1100

    } = opts;

2771

2772

1100

    let pw = (width * dpi_factor) as u32;

2773

1100

    let ph = (height * dpi_factor) as u32;

2774

1100

    let mut pixmap = acquire_pixmap(retained, pw, ph)?;

2775

1100

    pixmap.fill(255, 255, 255, 255);

2776

2777

1100

    render_display_list_with_state(

2778

1100

dl,

2779

1100

        &mut pixmap,

2780

1100

        dpi_factor,

2781

1100

        res,

2782

1100

        Some(font_manager),

2783

1100

        glyph_cache,

2784

1100

        render_state,

2785

)?;

2786

2787

1100

    Ok(pixmap)

2788

1100

2789

2790

/// Scroll offsets keyed by scroll_id (LocalScrollId).

2791

/// Passed to the renderer so it can look up the current scroll position

2792

/// for each PushScrollFrame without embedding it in the display list.

2793

pub type ScrollOffsetMap = HashMap<LocalScrollId, (f32, f32)>;

2794

2795

/// Compute damage rects by comparing two display lists item by item.

2796

///

2797

/// Returns a list of bounding rects that need repainting, or `None` if a

2798

/// full repaint is required (structural change, different item count, etc.).

2799

///

2800

/// The comparison is conservative: any item whose bounds or content changed

2801

/// produces a damage rect covering both the old and new bounds.

2802

132

pub fn compute_display_list_damage(

2803

132

    old: &DisplayList,

2804

132

    new: &DisplayList,

2805

132

) -> Option<Vec<LogicalRect>> {

2806

    // Different item counts → structural change → full repaint

2807

132

    if old.items.len() != new.items.len() {

2808

132

        return None;

2809

2810

2811

    let mut damage = Vec::new();

2812

2813

    for (old_item, new_item) in old.items.iter().zip(new.items.iter()) {

2814

        // Compare discriminant first (cheap)

2815

        if std::mem::discriminant(old_item) != std::mem::discriminant(new_item) {

2816

            return None; // structural change

2817

2818

2819

        // Compare full visual content, not just bounds — a color or text

2820

        // change within the same bounds must still produce a damage rect.

2821

        // Use visual_bounds() to include effects like box-shadow extent.

2822

        if !old_item.is_visually_equal(new_item) {

2823

            let old_bounds = old_item.visual_bounds();

2824

            let new_bounds = new_item.visual_bounds();

2825

            if let Some(ob) = old_bounds {

2826

                damage.push(ob);

2827

2828

            if let Some(nb) = new_bounds {

2829

                damage.push(nb);

2830

2831

2832

2833

2834

    // Coalesce overlapping rects

2835

    coalesce_damage_rects(&mut damage);

2836

    Some(damage)

2837

132

2838

2839

/// Are two display lists visually identical? (same length, same item

2840

/// discriminants, every item `is_visually_equal`). Cheaper proxy than a

2841

/// structural hash, reusing the same per-item comparison the damage diff uses.

2842

pub fn display_lists_visually_equal(a: &DisplayList, b: &DisplayList) -> bool {

2843

    if a.items.len() != b.items.len() {

2844

        return false;

2845

2846

    a.items.iter().zip(b.items.iter()).all(|(x, y)| {

2847

        std::mem::discriminant(x) == std::mem::discriminant(y) && x.is_visually_equal(y)

2848

})

2849

2850

2851

/// Damage rects for `VirtualView` child DOMs whose content changed since the

2852

/// previous frame.

2853

///

2854

/// The parent display list only carries a `VirtualView { child_dom_id, bounds }`

2855

/// item that stays byte-identical when the *child* DOM re-renders (e.g. a

2856

/// MapWidget tile arriving on a worker thread and re-invoking the VirtualView

2857

/// in place). So `compute_display_list_damage` — which only diffs the parent —

2858

/// reports "nothing changed", and `render_frame` would skip the frame, freezing

2859

/// the child content. This compares each VirtualView's child DL against the

2860

/// previous frame's and returns the on-screen bounds of every one that differs,

2861

/// so the caller can damage exactly those regions.

2862

///

2863

/// `current` / `previous` are keyed by the child `DomId` (the non-root entries

2864

/// of `layout_results`). A child that is newly present or newly absent counts

2865

/// as changed.

2866

pub fn compute_virtual_view_damage(

2867

    parent: &DisplayList,

2868

    current: &std::collections::BTreeMap<azul_core::dom::DomId, std::sync::Arc<DisplayList>>,

2869

    previous: &std::collections::BTreeMap<azul_core::dom::DomId, std::sync::Arc<DisplayList>>,

2870

) -> Vec<LogicalRect> {

2871

    let mut damage = Vec::new();

2872

    for item in parent.items.iter() {

2873

        if let DisplayListItem::VirtualView { child_dom_id, bounds, .. } = item {

2874

            let changed = match (current.get(child_dom_id), previous.get(child_dom_id)) {

2875

                (Some(c), Some(p)) => {

2876

                    // Same Arc → definitely unchanged (cheap fast-path).

2877

                    !std::sync::Arc::ptr_eq(c, p) && !display_lists_visually_equal(c, p)

2878

2879

                (Some(_), None) | (None, Some(_)) => true,

2880

                (None, None) => false,

2881

};

2882

            if changed {

2883

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

2884

2885

2886

2887

    damage

2888

2889

2890

/// Merge overlapping or adjacent damage rects to reduce overdraw.

2891

fn coalesce_damage_rects(rects: &mut Vec<LogicalRect>) {

2892

    if rects.len() <= 1 {

2893

        return;

2894

2895

2896

    // Simple O(n^2) merge — fine for typical damage counts (<20 rects)

2897

    let mut changed = true;

2898

    while changed {

2899

        changed = false;

2900

        let mut i = 0;

2901

        while i < rects.len() {

2902

            let mut j = i + 1;

2903

            while j < rects.len() {

2904

                // 8 logical pixels: merge rects that are close enough to avoid

2905

                // many tiny damage regions that would cause redundant repaints —

2906

                // BUT only when the merged box doesn't balloon the repaint. Two

2907

                // PERPENDICULAR thin strips (e.g. a vertical + a horizontal

2908

                // scrollbar meeting at a corner) are "adjacent" yet their bounding

2909

                // box is the whole viewport: merging them turns ~3k px of overdraw

2910

                // into ~20k. Reject a merge whose union is much larger than the two

2911

                // rects combined; keep them separate instead.

2912

                if rects_overlap_or_adjacent(&rects[i], &rects[j], 8.0) {

2913

                    let u = union_rect(&rects[i], &rects[j]);

2914

                    let area_u = (u.size.width * u.size.height).max(0.0);

2915

                    let area_i = (rects[i].size.width * rects[i].size.height).max(0.0);

2916

                    let area_j = (rects[j].size.width * rects[j].size.height).max(0.0);

2917

                    // 1.5× slack covers genuine overlap (union < sum) and small-gap

2918

                    // tiling (union ≈ sum) while rejecting perpendicular-strip bboxes.

2919

                    if area_u <= (area_i + area_j) * 1.5 + 64.0 {

2920

                        rects[i] = u;

2921

                        rects.swap_remove(j);

2922

                        changed = true;

2923

                    } else {

2924

                        j += 1;

2925

2926

                } else {

2927

                    j += 1;

2928

2929

2930

            i += 1;

2931

2932

2933

2934

2935

136

fn rects_overlap_or_adjacent(a: &LogicalRect, b: &LogicalRect, gap: f32) -> bool {

2936

136

    a.origin.x - gap <= b.origin.x + b.size.width

2937

136

        && b.origin.x - gap <= a.origin.x + a.size.width

2938

136

        && a.origin.y - gap <= b.origin.y + b.size.height

2939

136

        && b.origin.y - gap <= a.origin.y + a.size.height

2940

136

2941

2942

pub fn union_rect(a: &LogicalRect, b: &LogicalRect) -> LogicalRect {

2943

    let x = a.origin.x.min(b.origin.x);

2944

    let y = a.origin.y.min(b.origin.y);

2945

    let right = (a.origin.x + a.size.width).max(b.origin.x + b.size.width);

2946

    let bottom = (a.origin.y + a.size.height).max(b.origin.y + b.size.height);

2947

    LogicalRect {

2948

        origin: LogicalPosition { x, y },

2949

        size: LogicalSize {

2950

            width: right - x,

2951

            height: bottom - y,

2952

},

2953

2954

2955

2956

/// Compute damage rects for a grow-only window resize.

2957

/// Returns the right strip and bottom strip that need rendering.

2958

pub fn compute_resize_damage(

2959

    old_width: f32,

2960

    old_height: f32,

2961

    new_width: f32,

2962

    new_height: f32,

2963

) -> Vec<LogicalRect> {

2964

    let mut rects = Vec::new();

2965

    if new_width > old_width {

2966

        rects.push(LogicalRect {

2967

            origin: LogicalPosition {

2968

                x: old_width,

2969

                y: 0.0,

2970

},

2971

            size: LogicalSize {

2972

                width: new_width - old_width,

2973

                height: new_height,

2974

},

2975

});

2976

2977

    if new_height > old_height {

2978

        rects.push(LogicalRect {

2979

            origin: LogicalPosition {

2980

                x: 0.0,

2981

                y: old_height,

2982

},

2983

            size: LogicalSize {

2984

                width: old_width.min(new_width),

2985

                height: new_height - old_height,

2986

},

2987

});

2988

2989

    rects

2990

2991

2992

/// Compare a rectangular sub-region of two pixmaps pixel-by-pixel.

2993

/// Returns the number of pixels that differ by more than `threshold` per channel.

2994

44

pub fn compare_region(

2995

44

    a: &AzulPixmap,

2996

44

    b: &AzulPixmap,

2997

44

    x: u32,

2998

44

    y: u32,

2999

44

    w: u32,

3000

44

    h: u32,

3001

44

    threshold: u8,

3002

44

) -> usize {

3003

44

    let mut diff_count = 0;

3004

8800

    for row in y..(y + h).min(a.height).min(b.height) {

3005

1760000

        for col in x..(x + w).min(a.width).min(b.width) {

3006

1760000

            let ai = (row * a.width + col) as usize * 4;

3007

1760000

            let bi = (row * b.width + col) as usize * 4;

3008

1760000

            if ai + 3 >= a.data.len() || bi + 3 >= b.data.len() {

3009

                continue;

3010

1760000

3011

1760000

            let dr = (a.data[ai] as i16 - b.data[bi] as i16).unsigned_abs() as u8;

3012

1760000

            let dg = (a.data[ai + 1] as i16 - b.data[bi + 1] as i16).unsigned_abs() as u8;

3013

1760000

            let db = (a.data[ai + 2] as i16 - b.data[bi + 2] as i16).unsigned_abs() as u8;

3014

1760000

            if dr > threshold || dg > threshold || db > threshold {

3015

                diff_count += 1;

3016

1760000

3017

3018

3019

44

    diff_count

3020

44

3021

3022

/// Consolidated render-time state for CPU rendering.

3023

///

3024

/// Bundles scroll offsets and GPU-animated values (transforms, opacities)

3025

/// that WebRender would normally manage internally. In cpurender these

3026

/// are looked up from the `GpuValueCache` at screenshot time.

3027

pub struct CpuRenderState {

3028

    /// Scroll offsets by scroll_id

3029

    pub scroll_offsets: ScrollOffsetMap,

3030

    /// Transform values keyed by TransformKey.id — scrollbar thumb positions

3031

    /// and CSS transforms that are GPU-animated in WebRender.

3032

    pub transforms: HashMap<usize, azul_core::transform::ComputedTransform3D>,

3033

    /// Opacity values keyed by OpacityKey.id — scrollbar fade-in/out.

3034

    /// For WhenScrolling mode, opacity is 1.0 when recently scrolled,

3035

    /// fades to 0.0 after idle. For Always mode, opacity is always 1.0.

3036

    pub opacities: HashMap<usize, f32>,

3037

    /// System style for resolving system color references inside gradient

3038

    /// stops (e.g. `system:accent` in macOS button backgrounds). When None,

3039

    /// system color stops fall back to a transparent color.

3040

    pub system_style: Option<std::sync::Arc<azul_css::system::SystemStyle>>,

3041

    /// Display lists of nested `VirtualView` child DOMs, keyed by their

3042

    /// `child_dom_id`. The WebRender path composites these via separate pipelines;

3043

    /// the CPU path has no pipelines, so the `DisplayListItem::VirtualView` arm

3044

    /// recursively rasterises the child's display list from here (translated to the

3045

    /// item's `bounds.origin`, clipped to `bounds`). Empty for non-window renders.

3046

    pub virtual_view_display_lists:

3047

        std::collections::BTreeMap<azul_core::dom::DomId, std::sync::Arc<DisplayList>>,

3048

    /// Resolved images for `DecodedImage::Callback` `<img>` nodes, keyed by the

3049

    /// callback image's hash. The CPU renderer can't invoke `RenderImageCallback`s

3050

    /// itself (it would draw a grey placeholder); the backend pre-invokes them

3051

    /// via [`crate::window::LayoutWindow::invoke_cpu_image_callbacks`] and passes

3052

    /// the produced images here, where the `DisplayListItem::Image` arm looks

3053

    /// them up by hash. Empty when there are no callback images.

3054

    pub image_callback_results:

3055

        std::collections::BTreeMap<azul_core::resources::ImageRefHash, azul_core::resources::ImageRef>,

3056

3057

3058

impl CpuRenderState {

3059

1936

    pub fn new(scroll_offsets: ScrollOffsetMap) -> Self {

3060

1936

        Self {

3061

1936

            scroll_offsets,

3062

1936

            transforms: HashMap::new(),

3063

1936

            opacities: HashMap::new(),

3064

1936

            system_style: None,

3065

1936

            virtual_view_display_lists: std::collections::BTreeMap::new(),

3066

1936

            image_callback_results: std::collections::BTreeMap::new(),

3067

1936

3068

1936

3069

3070

    /// Provide the resolved `RenderImageCallback` images (see the field doc).

3071

    pub fn with_image_callback_results(

3072

        mut self,

3073

        results: std::collections::BTreeMap<

3074

            azul_core::resources::ImageRefHash,

3075

            azul_core::resources::ImageRef,

3076

>,

3077

    ) -> Self {

3078

        self.image_callback_results = results;

3079

        self

3080

3081

3082

    /// Provide the nested `VirtualView` child DOM display lists so the CPU

3083

    /// renderer can composite them (see the field doc).

3084

88

    pub fn with_virtual_view_display_lists(

3085

88

        mut self,

3086

88

        lists: std::collections::BTreeMap<azul_core::dom::DomId, std::sync::Arc<DisplayList>>,

3087

88

    ) -> Self {

3088

88

        self.virtual_view_display_lists = lists;

3089

88

        self

3090

88

3091

3092

    /// Attach a `SystemStyle` so the renderer can resolve `system:*` color

3093

    /// keywords (e.g. in gradient stops) against the live OS palette.

3094

748

    pub fn with_system_style(

3095

748

        mut self,

3096

748

        system_style: Option<std::sync::Arc<azul_css::system::SystemStyle>>,

3097

748

    ) -> Self {

3098

748

        self.system_style = system_style;

3099

748

        self

3100

748

3101

3102

    /// Build from a GpuValueCache snapshot.

3103

    pub fn from_gpu_cache(

3104

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

3105

        dom_id: azul_core::dom::DomId,

3106

        scroll_offsets: &ScrollOffsetMap,

3107

    ) -> Self {

3108

        let mut transforms = HashMap::new();

3109

        let mut opacities = HashMap::new();

3110

3111

        if let Some(cache) = gpu_cache {

3112

            // Scrollbar thumb transforms (vertical)

3113

            for (node_id, key) in &cache.transform_keys {

3114

                if let Some(value) = cache.current_transform_values.get(node_id) {

3115

                    transforms.insert(key.id, value.clone());

3116

3117

3118

            // Scrollbar thumb transforms (horizontal)

3119

            for (node_id, key) in &cache.h_transform_keys {

3120

                if let Some(value) = cache.h_current_transform_values.get(node_id) {

3121

                    transforms.insert(key.id, value.clone());

3122

3123

3124

            // CSS transforms

3125

            for (node_id, key) in &cache.css_transform_keys {

3126

                if let Some(value) = cache.css_current_transform_values.get(node_id) {

3127

                    transforms.insert(key.id, value.clone());

3128

3129

3130

            // Scrollbar opacity (vertical)

3131

            for ((d, node_id), key) in &cache.scrollbar_v_opacity_keys {

3132

                if *d == dom_id {

3133

                    if let Some(&value) = cache.scrollbar_v_opacity_values.get(&(*d, *node_id)) {

3134

                        opacities.insert(key.id, value);

3135

3136

3137

3138

            // Scrollbar opacity (horizontal)

3139

            for ((d, node_id), key) in &cache.scrollbar_h_opacity_keys {

3140

                if *d == dom_id {

3141

                    if let Some(&value) = cache.scrollbar_h_opacity_values.get(&(*d, *node_id)) {

3142

                        opacities.insert(key.id, value);

3143

3144

3145

3146

            // CSS opacity

3147

            for (node_id, key) in &cache.opacity_keys {

3148

                if let Some(&value) = cache.current_opacity_values.get(node_id) {

3149

                    opacities.insert(key.id, value);

3150

3151

3152

3153

3154

        Self {

3155

            scroll_offsets: scroll_offsets.clone(),

3156

            transforms,

3157

            opacities,

3158

            system_style: None,

3159

            virtual_view_display_lists: std::collections::BTreeMap::new(),

3160

            image_callback_results: std::collections::BTreeMap::new(),

3161

3162

3163

3164

3165

fn render_display_list(

3166

    display_list: &DisplayList,

3167

    pixmap: &mut AzulPixmap,

3168

    dpi_factor: f32,

3169

    renderer_resources: &RendererResources,

3170

    font_manager: Option<&FontManager<FontRef>>,

3171

    glyph_cache: &mut GlyphCache,

3172

) -> Result<(), String> {

3173

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

3174

    render_display_list_with_state(

3175

        display_list,

3176

        pixmap,

3177

        dpi_factor,

3178

        renderer_resources,

3179

        font_manager,

3180

        glyph_cache,

3181

        &empty_state,

3182

3183

3184

3185

1848

fn render_display_list_with_state(

3186

1848

    display_list: &DisplayList,

3187

1848

    pixmap: &mut AzulPixmap,

3188

1848

    dpi_factor: f32,

3189

1848

    renderer_resources: &RendererResources,

3190

1848

    font_manager: Option<&FontManager<FontRef>>,

3191

1848

    glyph_cache: &mut GlyphCache,

3192

1848

    render_state: &CpuRenderState,

3193

1848

) -> Result<(), String> {

3194

1848

    let mut transform_stack = vec![TransAffine::new()]; // identity

3195

1848

    let mut clip_stack: Vec<Option<AzRect>> = vec![None];

3196

1848

    let mut mask_stack: Vec<MaskEntry> = Vec::new();

3197

    // Accumulated scroll offset stack. Each PushScrollFrame pushes

3198

    // (parent_offset_x + scroll_x, parent_offset_y + scroll_y).

3199

    // Items inside a scroll frame have their bounds shifted by the

3200

    // accumulated offset before rendering.

3201

1848

    let mut scroll_offset_stack: Vec<(f32, f32)> = vec![(0.0, 0.0)];

3202

3203

1848

    let _p_loop = crate::probe::Probe::span("raster_loop");

3204

18788

    for item in &display_list.items {

3205

16940

        let _p_item = crate::probe::Probe::span(probe_label_for_item(item));

3206

16940

        render_single_item(

3207

16940

            item,

3208

16940

            pixmap,

3209

16940

            dpi_factor,

3210

16940

            renderer_resources,

3211

16940

            font_manager,

3212

16940

            glyph_cache,

3213

16940

            &mut transform_stack,

3214

16940

            &mut clip_stack,

3215

16940

            &mut mask_stack,

3216

16940

            &mut scroll_offset_stack,

3217

16940

            render_state,

3218

)?;

3219

3220

3221

1848

    Ok(())

3222

1848

3223

3224

/// Compact item-kind label for [`crate::probe`]. Names must be `'static`

3225

/// strings (probe events store `&'static str` for cheap aggregation),

3226

/// hence the closed match instead of formatting `Debug`.

3227

#[inline]

3228

16940

fn probe_label_for_item(item: &DisplayListItem) -> &'static str {

3229

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

3230

16940

    match item {

3231

4048

        I::Rect { .. } => "dl:rect",

3232

        I::SelectionRect { .. } => "dl:sel_rect",

3233

880

        I::CursorRect { .. } => "dl:cursor",

3234

2948

        I::Border { .. } => "dl:border",

3235

1144

        I::Text { .. } => "dl:text",

3236

1144

        I::TextLayout { .. } => "dl:text_layout",

3237

132

        I::Image { .. } => "dl:image",

3238

        I::ScrollBar { .. } => "dl:scrollbar_raw",

3239

        I::ScrollBarStyled { .. } => "dl:scrollbar",

3240

        I::PushClip { .. } => "dl:push_clip",

3241

        I::PopClip => "dl:pop_clip",

3242

        I::PushScrollFrame { .. } => "dl:push_scroll",

3243

        I::PopScrollFrame => "dl:pop_scroll",

3244

1848

        I::PushStackingContext { .. } => "dl:push_stack",

3245

1848

        I::PopStackingContext => "dl:pop_stack",

3246

        I::PushReferenceFrame { .. } => "dl:push_ref",

3247

        I::PopReferenceFrame => "dl:pop_ref",

3248

        I::PushOpacity { .. } => "dl:push_opacity",

3249

        I::PopOpacity => "dl:pop_opacity",

3250

        I::PushFilter { .. } => "dl:push_filter",

3251

        I::PopFilter => "dl:pop_filter",

3252

        I::PushBackdropFilter { .. } => "dl:push_bdfilter",

3253

        I::PopBackdropFilter => "dl:pop_bdfilter",

3254

        I::PushTextShadow { .. } => "dl:push_tshadow",

3255

        I::PopTextShadow => "dl:pop_tshadow",

3256

220

        I::PushImageMaskClip { .. } => "dl:push_imask",

3257

220

        I::PopImageMaskClip => "dl:pop_imask",

3258

44

        I::LinearGradient { .. } => "dl:linear_grad",

3259

        I::RadialGradient { .. } => "dl:radial_grad",

3260

        I::ConicGradient { .. } => "dl:conic_grad",

3261

176

        I::BoxShadow { .. } => "dl:box_shadow",

3262

        I::Underline { .. } => "dl:underline",

3263

        I::Strikethrough { .. } => "dl:strike",

3264

        I::Overline { .. } => "dl:overline",

3265

2288

        I::HitTestArea { .. } => "dl:hit",

3266

        I::VirtualView { .. } => "dl:vview",

3267

        I::VirtualViewPlaceholder { .. } => "dl:vview_ph",

3268

3269

16940

3270

3271

/// Render only the damaged regions of a display list into a retained pixmap.

3272

///

3273

/// For each damage rect:

3274

/// 1. Clear that region in the pixmap (fill with background color).

3275

/// 2. Iterate all display list items, skip those entirely outside the damage rect.

3276

/// 3. Render intersecting items clipped to the damage rect.

3277

///

3278

/// Push/Pop state commands are always processed (they maintain clip/scroll stacks).

3279

44

pub fn render_display_list_damaged(

3280

44

    display_list: &DisplayList,

3281

44

    pixmap: &mut AzulPixmap,

3282

44

    dpi_factor: f32,

3283

44

    renderer_resources: &RendererResources,

3284

44

    font_manager: Option<&FontManager<FontRef>>,

3285

44

    glyph_cache: &mut GlyphCache,

3286

44

    render_state: &CpuRenderState,

3287

44

    damage_rects: &[LogicalRect],

3288

44

) -> Result<(), String> {

3289

44

    if damage_rects.is_empty() {

3290

        return Ok(()); // nothing changed

3291

44

3292

3293

    // Clear damaged regions to white

3294

88

    for dr in damage_rects {

3295

44

        let px = (dr.origin.x * dpi_factor) as i32;

3296

44

        let py = (dr.origin.y * dpi_factor) as i32;

3297

44

        let pw = (dr.size.width * dpi_factor) as i32;

3298

44

        let ph = (dr.size.height * dpi_factor) as i32;

3299

44

        pixmap.fill_rect(px, py, pw, ph, 255, 255, 255, 255);

3300

44

3301

3302

    // Items are individually tested against each damage rect below

3303

    // (line-by-line). We iterate items ONCE (not per-rect) to avoid

3304

    // double-rendering items that span multiple rects (alpha-blending artifacts).

3305

//

3306

    // The BASE CLIP is the union of the damage rects: an item that only

3307

    // PARTIALLY intersects the damage must not repaint its full bounds —

3308

    // otherwise it overpaints neighbours that don't intersect the damage and

3309

    // therefore never repaint. (Live bug: the maps header background TOUCHES

3310

    // the VirtualView damage band below it, so it repainted all 70px of

3311

    // header — wiping the toolbar buttons, which lie outside the damage and

3312

    // were skipped. The toolbar vanished on the first incremental frame.)

3313

44

    let union = {

3314

44

        let mut it = damage_rects.iter();

3315

44

        let first = *it.next().unwrap();

3316

44

        it.fold(first, |acc, r| union_rect(&acc, r))

3317

};

3318

44

    let base_clip = logical_rect_to_az_rect(&union, dpi_factor);

3319

44

    let mut transform_stack = vec![TransAffine::new()];

3320

44

    let mut clip_stack: Vec<Option<AzRect>> = vec![base_clip];

3321

44

    let mut mask_stack: Vec<MaskEntry> = Vec::new();

3322

44

    let mut scroll_offset_stack: Vec<(f32, f32)> = vec![(0.0, 0.0)];

3323

3324

220

    for item in display_list.items.iter() {

3325

        // Always process state-management items (Push/Pop) regardless of bounds,

3326

        // because skipping a Push while processing its matching Pop corrupts stacks.

3327

220

        if !item.is_state_management() {

3328

132

            if let Some(item_bounds) = item.bounds() {

3329

                // Items inside a scroll frame are stored at CONTENT coords but

3330

                // RENDER at `pos - scroll_offset`. The damage rects are in viewport

3331

                // space, so we must apply the current scroll offset to the bounds

3332

                // before the intersection test — otherwise scrolled content is

3333

                // filtered against the wrong position and rows that actually fall

3334

                // in a damage strip get dropped (visible as a missing band).

3335

132

                let (sdx, sdy) = *scroll_offset_stack.last().unwrap_or(&(0.0, 0.0));

3336

132

                let test_bounds = if sdx == 0.0 && sdy == 0.0 {

3337

132

                    item_bounds

3338

                } else {

3339

                    LogicalRect {

3340

                        origin: LogicalPosition {

3341

                            x: item_bounds.origin.x - sdx,

3342

                            y: item_bounds.origin.y - sdy,

3343

},

3344

                        size: item_bounds.size,

3345

3346

};

3347

                // Check if item intersects ANY damage rect (not just the union)

3348

132

                let hits_damage = damage_rects

3349

132

                    .iter()

3350

132

                    .any(|dr| rects_overlap_or_adjacent(&test_bounds, dr, 0.0));

3351

132

                if !hits_damage {

3352

44

                    continue;

3353

88

3354

3355

88

3356

3357

176

        render_single_item(

3358

176

            item,

3359

176

            pixmap,

3360

176

            dpi_factor,

3361

176

            renderer_resources,

3362

176

            font_manager,

3363

176

            glyph_cache,

3364

176

            &mut transform_stack,

3365

176

            &mut clip_stack,

3366

176

            &mut mask_stack,

3367

176

            &mut scroll_offset_stack,

3368

176

            render_state,

3369

)?;

3370

3371

3372

44

    Ok(())

3373

44

3374

3375

29700

fn render_single_item(

3376

29700

    item: &DisplayListItem,

3377

29700

    pixmap: &mut AzulPixmap,

3378

29700

    dpi_factor: f32,

3379

29700

    renderer_resources: &RendererResources,

3380

29700

    font_manager: Option<&FontManager<FontRef>>,

3381

29700

    glyph_cache: &mut GlyphCache,

3382

29700

    transform_stack: &mut Vec<TransAffine>,

3383

29700

    clip_stack: &mut Vec<Option<AzRect>>,

3384

29700

    mask_stack: &mut Vec<MaskEntry>,

3385

29700

    scroll_offset_stack: &mut Vec<(f32, f32)>,

3386

29700

    render_state: &CpuRenderState,

3387

29700

) -> Result<(), String> {

3388

    // Current accumulated scroll offset — applied to all item bounds.

3389

    // Negative because scrolling down (positive offset) moves content up.

3390

29700

    let (scroll_dx, scroll_dy) = *scroll_offset_stack.last().unwrap_or(&(0.0, 0.0));

3391

3392

    // Helper: apply scroll offset to a LogicalRect.

3393

    // Items inside scroll frames have absolute window coordinates;

3394

    // the scroll offset shifts them so the visible portion aligns

3395

    // with the clip region.

3396

29700

    let scroll_rect = |r: &LogicalRect| -> LogicalRect {

3397

17248

        if scroll_dx == 0.0 && scroll_dy == 0.0 {

3398

11704

            return *r;

3399

5544

3400

5544

        LogicalRect {

3401

5544

            origin: LogicalPosition {

3402

5544

                x: r.origin.x - scroll_dx,

3403

5544

                y: r.origin.y - scroll_dy,

3404

5544

},

3405

5544

            size: r.size,

3406

5544

3407

17248

};

3408

3409

29700

    match item {

3410

        DisplayListItem::Rect {

3411

5632

            bounds,

3412

5632

            color,

3413

5632

            border_radius,

3414

        } => {

3415

5632

            let clip = *clip_stack.last().unwrap();

3416

5632

            render_rect(

3417

5632

                pixmap,

3418

5632

                &scroll_rect(bounds.inner()),

3419

5632

                *color,

3420

5632

                border_radius,

3421

5632

                clip,

3422

5632

                dpi_factor,

3423

)?;

3424

3425

        DisplayListItem::SelectionRect {

3426

            bounds,

3427

            color,

3428

            border_radius,

3429

        } => {

3430

            let clip = *clip_stack.last().unwrap();

3431

            render_rect(

3432

                pixmap,

3433

                &scroll_rect(bounds.inner()),

3434

                *color,

3435

                border_radius,

3436

                clip,

3437

                dpi_factor,

3438

)?;

3439

3440

880

        DisplayListItem::CursorRect { bounds, color } => {

3441

880

            let clip = *clip_stack.last().unwrap();

3442

880

            render_rect(

3443

880

                pixmap,

3444

880

                &scroll_rect(bounds.inner()),

3445

880

                *color,

3446

880

                &BorderRadius::default(),

3447

880

                clip,

3448

880

                dpi_factor,

3449

)?;

3450

3451

        DisplayListItem::Border {

3452

4576

            bounds,

3453

4576

            widths,

3454

4576

            colors,

3455

4576

            styles,

3456

4576

            border_radius,

3457

        } => {

3458

4576

            let default_color = ColorU {

3459

4576

                r: 0,

3460

4576

                g: 0,

3461

4576

                b: 0,

3462

4576

                a: 255,

3463

4576

};

3464

3465

4576

            let w_top = widths

3466

4576

                .top

3467

4576

                .and_then(|w| w.get_property().cloned())

3468

4576

                .map(|w| {

3469

4576

                    w.inner

3470

4576

                        .to_pixels_internal(0.0, DEFAULT_FONT_SIZE, DEFAULT_FONT_SIZE)

3471

4576

})

3472

4576

                .unwrap_or(0.0);

3473

4576

            let w_right = widths

3474

4576

                .right

3475

4576

                .and_then(|w| w.get_property().cloned())

3476

4576

                .map(|w| {

3477

4576

                    w.inner

3478

4576

                        .to_pixels_internal(0.0, DEFAULT_FONT_SIZE, DEFAULT_FONT_SIZE)

3479

4576

})

3480

4576

                .unwrap_or(0.0);

3481

4576

            let w_bottom = widths

3482

4576

                .bottom

3483

4576

                .and_then(|w| w.get_property().cloned())

3484

4576

                .map(|w| {

3485

4576

                    w.inner

3486

4576

                        .to_pixels_internal(0.0, DEFAULT_FONT_SIZE, DEFAULT_FONT_SIZE)

3487

4576

})

3488

4576

                .unwrap_or(0.0);

3489

4576

            let w_left = widths

3490

4576

                .left

3491

4576

                .and_then(|w| w.get_property().cloned())

3492

4576

                .map(|w| {

3493

4576

                    w.inner

3494

4576

                        .to_pixels_internal(0.0, DEFAULT_FONT_SIZE, DEFAULT_FONT_SIZE)

3495

4576

})

3496

4576

                .unwrap_or(0.0);

3497

3498

4576

            let c_top = colors

3499

4576

                .top

3500

4576

                .and_then(|c| c.get_property().cloned())

3501

4576

                .map(|c| c.inner)

3502

4576

                .unwrap_or(default_color);

3503

4576

            let c_right = colors

3504

4576

                .right

3505

4576

                .and_then(|c| c.get_property().cloned())

3506

4576

                .map(|c| c.inner)

3507

4576

                .unwrap_or(default_color);

3508

4576

            let c_bottom = colors

3509

4576

                .bottom

3510

4576

                .and_then(|c| c.get_property().cloned())

3511

4576

                .map(|c| c.inner)

3512

4576

                .unwrap_or(default_color);

3513

4576

            let c_left = colors

3514

4576

                .left

3515

4576

                .and_then(|c| c.get_property().cloned())

3516

4576

                .map(|c| c.inner)

3517

4576

                .unwrap_or(default_color);

3518

3519

            use azul_css::props::style::border::BorderStyle;

3520

4576

            let s_top = styles

3521

4576

                .top

3522

4576

                .and_then(|s| s.get_property().cloned())

3523

4576

                .map(|s| s.inner)

3524

4576

                .unwrap_or(BorderStyle::Solid);

3525

4576

            let s_right = styles

3526

4576

                .right

3527

4576

                .and_then(|s| s.get_property().cloned())

3528

4576

                .map(|s| s.inner)

3529

4576

                .unwrap_or(BorderStyle::Solid);

3530

4576

            let s_bottom = styles

3531

4576

                .bottom

3532

4576

                .and_then(|s| s.get_property().cloned())

3533

4576

                .map(|s| s.inner)

3534

4576

                .unwrap_or(BorderStyle::Solid);

3535

4576

            let s_left = styles

3536

4576

                .left

3537

4576

                .and_then(|s| s.get_property().cloned())

3538

4576

                .map(|s| s.inner)

3539

4576

                .unwrap_or(BorderStyle::Solid);

3540

3541

4576

            let simple_radius = BorderRadius {

3542

4576

                top_left: border_radius.top_left.to_pixels_internal(

3543

4576

                    bounds.0.size.width,

3544

4576

                    DEFAULT_FONT_SIZE,

3545

4576

                    DEFAULT_FONT_SIZE,

3546

4576

),

3547

4576

                top_right: border_radius.top_right.to_pixels_internal(

3548

4576

                    bounds.0.size.width,

3549

4576

                    DEFAULT_FONT_SIZE,

3550

4576

                    DEFAULT_FONT_SIZE,

3551

4576

),

3552

4576

                bottom_left: border_radius.bottom_left.to_pixels_internal(

3553

4576

                    bounds.0.size.width,

3554

4576

                    DEFAULT_FONT_SIZE,

3555

4576

                    DEFAULT_FONT_SIZE,

3556

4576

),

3557

4576

                bottom_right: border_radius.bottom_right.to_pixels_internal(

3558

4576

                    bounds.0.size.width,

3559

4576

                    DEFAULT_FONT_SIZE,

3560

4576

                    DEFAULT_FONT_SIZE,

3561

4576

),

3562

4576

};

3563

3564

4576

            let clip = *clip_stack.last().unwrap();

3565

4576

            let b = scroll_rect(bounds.inner());

3566

3567

            // If all sides same color/width/style, use single render_border call

3568

4576

            let all_same = c_top == c_right

3569

4576

                && c_top == c_bottom

3570

4576

                && c_top == c_left

3571

4576

                && w_top == w_right

3572

4576

                && w_top == w_bottom

3573

4576

                && w_top == w_left

3574

4576

                && s_top == s_right

3575

4576

                && s_top == s_bottom

3576

4576

                && s_top == s_left;

3577

3578

4576

            if all_same {

3579

4576

                render_border(

3580

4576

                    pixmap,

3581

4576

&b,

3582

4576

                    c_top,

3583

4576

                    w_top,

3584

4576

                    s_top,

3585

4576

                    &simple_radius,

3586

4576

                    clip,

3587

4576

                    dpi_factor,

3588

)?;

3589

            } else {

3590

                // Per-side rendering: render each side separately

3591

                render_border_sides(

3592

                    pixmap,

3593

&b,

3594

                    [c_top, c_right, c_bottom, c_left],

3595

                    [w_top, w_right, w_bottom, w_left],

3596

                    [s_top, s_right, s_bottom, s_left],

3597

                    &simple_radius,

3598

                    clip,

3599

                    dpi_factor,

3600

)?;

3601

3602

3603

        DisplayListItem::Underline {

3604

            bounds,

3605

            color,

3606

            thickness: _,

3607

        } => {

3608

            let clip = *clip_stack.last().unwrap();

3609

            render_rect(

3610

                pixmap,

3611

                &scroll_rect(bounds.inner()),

3612

                *color,

3613

                &BorderRadius::default(),

3614

                clip,

3615

                dpi_factor,

3616

)?;

3617

3618

        DisplayListItem::Strikethrough {

3619

            bounds,

3620

            color,

3621

            thickness: _,

3622

        } => {

3623

            let clip = *clip_stack.last().unwrap();

3624

            render_rect(

3625

                pixmap,

3626

                &scroll_rect(bounds.inner()),

3627

                *color,

3628

                &BorderRadius::default(),

3629

                clip,

3630

                dpi_factor,

3631

)?;

3632

3633

        DisplayListItem::Overline {

3634

            bounds,

3635

            color,

3636

            thickness: _,

3637

        } => {

3638

            let clip = *clip_stack.last().unwrap();

3639

            render_rect(

3640

                pixmap,

3641

                &scroll_rect(bounds.inner()),

3642

                *color,

3643

                &BorderRadius::default(),

3644

                clip,

3645

                dpi_factor,

3646

)?;

3647

3648

        DisplayListItem::Text {

3649

5192

            glyphs,

3650

5192

            font_size_px,

3651

5192

            font_hash,

3652

5192

            color,

3653

5192

            clip_rect,

3654

..

3655

        } => {

3656

5192

            let clip = *clip_stack.last().unwrap();

3657

5192

            render_text(

3658

5192

                glyphs,

3659

5192

                *font_hash,

3660

5192

                *font_size_px,

3661

5192

                *color,

3662

5192

                pixmap,

3663

5192

                &scroll_rect(clip_rect.inner()),

3664

5192

                clip,

3665

5192

                renderer_resources,

3666

5192

                font_manager,

3667

5192

                dpi_factor,

3668

5192

                glyph_cache,

3669

5192

                (scroll_dx, scroll_dy),

3670

)?;

3671

3672

        DisplayListItem::TextLayout {

3673

3344

            layout,

3674

3344

            bounds,

3675

3344

            font_hash,

3676

3344

            font_size_px,

3677

3344

            color,

3678

3344

        } => {

3679

3344

            // TextLayout is metadata for PDF/accessibility - skip in CPU rendering

3680

3344

3681

132

        DisplayListItem::Image { bounds, image, .. } => {

3682

132

            let clip = *clip_stack.last().unwrap();

3683

            // A `DecodedImage::Callback` `<img>` (e.g. the AzulPaint canvas) can't

3684

            // be rasterised here — the renderer can't run the callback. The backend

3685

            // pre-invoked it into `image_callback_results`; swap in the produced

3686

            // image (keyed by the callback image's hash). Falls back to `image`

3687

            // (→ grey placeholder) only if no result was produced.

3688

132

            let resolved = render_state.image_callback_results.get(&image.get_hash());

3689

132

            render_image(

3690

132

                pixmap,

3691

132

                &scroll_rect(bounds.inner()),

3692

132

                resolved.unwrap_or(image),

3693

132

                clip,

3694

132

                dpi_factor,

3695

)?;

3696

3697

        DisplayListItem::ScrollBar {

3698

            bounds,

3699

            color,

3700

            orientation,

3701

            opacity_key: _,

3702

            hit_id: _,

3703

        } => {

3704

            let clip = *clip_stack.last().unwrap();

3705

            render_rect(

3706

                pixmap,

3707

                &scroll_rect(bounds.inner()),

3708

                *color,

3709

                &BorderRadius::default(),

3710

                clip,

3711

                dpi_factor,

3712

)?;

3713

3714

        DisplayListItem::ScrollBarStyled { info } => {

3715

            let clip = *clip_stack.last().unwrap();

3716

3717

            // Resolve scrollbar opacity from the GPU value cache.

3718

            // WhenScrolling mode starts at 0.0 and fades to 1.0 on scroll.

3719

            // In cpurender we read the current value; if none is cached

3720

            // (e.g. headless mode never ran synchronize_scrollbar_opacity)

3721

            // default to 1.0 so the scrollbar is always visible.

3722

            let scrollbar_opacity = info

3723

                .opacity_key

3724

                .and_then(|key| render_state.opacities.get(&key.id).copied())

3725

                .unwrap_or(1.0);

3726

3727

            if scrollbar_opacity > 0.001 {

3728

                // Render track

3729

                if info.track_color.a > 0 {

3730

                    render_rect(

3731

                        pixmap,

3732

                        &scroll_rect(info.track_bounds.inner()),

3733

                        info.track_color,

3734

                        &BorderRadius::default(),

3735

                        clip,

3736

                        dpi_factor,

3737

)?;

3738

3739

3740

                // Render decrement button

3741

                if let Some(btn_bounds) = &info.button_decrement_bounds {

3742

                    if info.button_color.a > 0 {

3743

                        render_rect(

3744

                            pixmap,

3745

                            &scroll_rect(btn_bounds.inner()),

3746

                            info.button_color,

3747

                            &BorderRadius::default(),

3748

                            clip,

3749

                            dpi_factor,

3750

)?;

3751

3752

3753

3754

                // Render increment button

3755

                if let Some(btn_bounds) = &info.button_increment_bounds {

3756

                    if info.button_color.a > 0 {

3757

                        render_rect(

3758

                            pixmap,

3759

                            &scroll_rect(btn_bounds.inner()),

3760

                            info.button_color,

3761

                            &BorderRadius::default(),

3762

                            clip,

3763

                            dpi_factor,

3764

)?;

3765

3766

3767

3768

                // Render thumb — the thumb is wrapped in PushReferenceFrame

3769

                // with a thumb_transform_key, so the GPU cache lookup handles

3770

                // positioning dynamically. Here we just apply the initial

3771

                // transform embedded in the display list item as a fallback.

3772

                if info.thumb_color.a > 0 {

3773

                    let thumb_rect = info.thumb_bounds.inner();

3774

                    // Look up live transform from render_state if available

3775

                    let transform = info

3776

                        .thumb_transform_key

3777

                        .and_then(|key| render_state.transforms.get(&key.id))

3778

                        .unwrap_or(&info.thumb_initial_transform);

3779

                    let tx = transform.m[3][0];

3780

                    let ty = transform.m[3][1];

3781

                    let transformed_thumb = LogicalRect {

3782

                        origin: LogicalPosition {

3783

                            x: thumb_rect.origin.x + tx,

3784

                            y: thumb_rect.origin.y + ty,

3785

},

3786

                        size: thumb_rect.size,

3787

};

3788

                    render_rect(

3789

                        pixmap,

3790

                        &scroll_rect(&transformed_thumb),

3791

                        info.thumb_color,

3792

                        &info.thumb_border_radius,

3793

                        clip,

3794

                        dpi_factor,

3795

)?;

3796

3797

            } // end scrollbar_opacity > 0

3798

3799

        DisplayListItem::PushClip {

3800

264

            bounds,

3801

264

            border_radius,

3802

264

        } => {

3803

264

            // Two fixes (the invisible-maps-header bug):

3804

264

            // 1. The clip must live in the same coordinate space items draw in

3805

264

            //    (`pos - accumulated_scroll`) — shift it via scroll_rect() like

3806

264

            //    every drawing arm. A VirtualView child's PushClip otherwise

3807

264

            //    lands at raw child-local coordinates on the window.

3808

264

            // 2. A nested clip can only NARROW the active one. Pushing the rect

3809

264

            //    verbatim let a child DL's own PushClip REPLACE the VirtualView

3810

264

            //    composite clip, so the child painted over the whole window

3811

264

            //    (the maps header/toolbar disappeared under the tile grid).

3812

264

            let new_clip = logical_rect_to_az_rect(&scroll_rect(bounds.inner()), dpi_factor);

3813

264

            let merged = intersect_clips(clip_stack.last().copied().flatten(), new_clip);

3814

264

            clip_stack.push(merged);

3815

264

3816

        DisplayListItem::PopClip => {

3817

            // Never pop the base clip (the window rect pushed at init). An

3818

            // unbalanced PopClip — e.g. a display-list bookkeeping mismatch in

3819

            // the titlebar/stacking-context emit path — must NOT abort the whole

3820

            // layer render. Previously this returned Err, the caller logged

3821

            // "render_layers error: Clip stack underflow" and DROPPED THE ENTIRE

3822

            // FRAME, leaving a blank window with no body/button. Clamp to the base

3823

            // instead so the frame still presents; the only effect of an over-pop

3824

            // is that trailing items fall back to the base (window) clip, which is

3825

            // harmless for well-formed DOMs.

3826

264

            if clip_stack.len() > 1 {

3827

264

                clip_stack.pop();

3828

264

            } else {

3829

                #[cfg(feature = "std")]

3830

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

3831

                    eprintln!(

3832

                        "[CpuBackend] PopClip with no matching PushClip — clamping to base clip"

3833

);

3834

3835

3836

3837

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

3838

            // Scroll frame = scroll offset only.

3839

            // The display list generator always emits PushClip before

3840

            // PushScrollFrame with the same clip bounds, so we don't

3841

            // need to push another clip here — that would double-clip.

3842

            transform_stack.push(

3843

                transform_stack

3844

                    .last()

3845

                    .cloned()

3846

                    .unwrap_or_else(TransAffine::new),

3847

);

3848

            let frame_offset = render_state

3849

                .scroll_offsets

3850

                .get(scroll_id)

3851

                .copied()

3852

                .unwrap_or((0.0, 0.0));

3853

            let new_scroll = (scroll_dx + frame_offset.0, scroll_dy + frame_offset.1);

3854

            scroll_offset_stack.push(new_scroll);

3855

3856

        DisplayListItem::PopScrollFrame => {

3857

            // Only pop transform and scroll offset — the clip was pushed

3858

            // by a separate PushClip and will be popped by PopClip.

3859

            if transform_stack.len() > 1 {

3860

                transform_stack.pop();

3861

3862

            if scroll_offset_stack.len() > 1 {

3863

                scroll_offset_stack.pop();

3864

3865

3866

4752

        DisplayListItem::HitTestArea { bounds, tag } => {

3867

4752

            // Hit test areas don't render anything

3868

4752

3869

1936

        DisplayListItem::PushStackingContext { z_index, bounds } => {

3870

1936

            // For CPU rendering, stacking contexts are already handled by display list order

3871

1936

3872

1936

        DisplayListItem::PopStackingContext => {}

3873

        DisplayListItem::VirtualView {

3874

132

            child_dom_id,

3875

132

            bounds,

3876

132

            clip_rect,

3877

        } => {

3878

132

            let _ = clip_rect;

3879

            // Composite the VirtualView's child DOM (a separate LayoutResult the

3880

            // normal layout loop produced — e.g. the MapWidget's tile grid). Its

3881

            // display list is 0-relative, so we (1) clip to the VirtualView's

3882

            // on-screen rect and (2) push a scroll offset of -bounds.origin so the

3883

            // renderer (which draws at `pos - accumulated_scroll`) places the child

3884

            // content at the VirtualView origin. Then recursively rasterise it.

3885

            // (Was: a debug-blue overlay that never drew the child — the reason the

3886

            // CPU backend showed a blank map.)

3887

132

            let child_dl = render_state.virtual_view_display_lists.get(child_dom_id).cloned();

3888

            #[cfg(feature = "std")]

3889

132

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

3890

                eprintln!(

3891

                    "[cpu-vview] VirtualView item: child_dom_id={} found={} items={} bounds={:?} avail_ids={:?}",

3892

                    child_dom_id.inner,

3893

                    child_dl.is_some(),

3894

                    child_dl.as_ref().map(|d| d.items.len()).unwrap_or(0),

3895

                    bounds.inner(),

3896

                    render_state.virtual_view_display_lists.keys().map(|k| k.inner).collect::<alloc::vec::Vec<_>>(),

3897

);

3898

132

3899

132

            if let Some(child_dl) = child_dl {

3900

132

                let vv_origin = bounds.inner().origin;

3901

                // Intersect with the active clip (the VirtualView may itself sit

3902

                // inside a clipped/scrolled container) — same rule as PushClip.

3903

132

                let vv_clip = intersect_clips(

3904

132

                    clip_stack.last().copied().flatten(),

3905

132

                    logical_rect_to_az_rect(&scroll_rect(bounds.inner()), dpi_factor),

3906

);

3907

132

                clip_stack.push(vv_clip);

3908

132

                scroll_offset_stack.push((scroll_dx - vv_origin.x, scroll_dy - vv_origin.y));

3909

9328

                for child_item in child_dl.items.iter() {

3910

9328

                    render_single_item(

3911

9328

                        child_item,

3912

9328

                        pixmap,

3913

9328

                        dpi_factor,

3914

9328

                        renderer_resources,

3915

9328

                        font_manager,

3916

9328

                        glyph_cache,

3917

9328

                        transform_stack,

3918

9328

                        clip_stack,

3919

9328

                        mask_stack,

3920

9328

                        scroll_offset_stack,

3921

9328

                        render_state,

3922

)?;

3923

3924

132

                scroll_offset_stack.pop();

3925

132

                clip_stack.pop();

3926

3927

3928

        DisplayListItem::VirtualViewPlaceholder { .. } => {

3929

            #[cfg(feature = "std")]

3930

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

3931

                eprintln!("[cpu-vview] VirtualViewPlaceholder hit (NOT swapped to a VirtualView item — nothing composites)");

3932

3933

3934

3935

        // Gradient rendering

3936

        DisplayListItem::LinearGradient {

3937

44

            bounds,

3938

44

            gradient,

3939

44

            border_radius,

3940

        } => {

3941

44

            let clip = *clip_stack.last().unwrap();

3942

44

            render_linear_gradient(

3943

44

                pixmap,

3944

44

                &scroll_rect(bounds.inner()),

3945

44

                gradient,

3946

44

                border_radius,

3947

44

                clip,

3948

44

                dpi_factor,

3949

44

                render_state.system_style.as_deref().map(|s| &s.colors),

3950

)?;

3951

3952

        DisplayListItem::RadialGradient {

3953

            bounds,

3954

            gradient,

3955

            border_radius,

3956

        } => {

3957

            let clip = *clip_stack.last().unwrap();

3958

            render_radial_gradient(

3959

                pixmap,

3960

                &scroll_rect(bounds.inner()),

3961

                gradient,

3962

                border_radius,

3963

                clip,

3964

                dpi_factor,

3965

                render_state.system_style.as_deref().map(|s| &s.colors),

3966

)?;

3967

3968

        DisplayListItem::ConicGradient {

3969

            bounds,

3970

            gradient,

3971

            border_radius,

3972

        } => {

3973

            let clip = *clip_stack.last().unwrap();

3974

            render_conic_gradient(

3975

                pixmap,

3976

                &scroll_rect(bounds.inner()),

3977

                gradient,

3978

                border_radius,

3979

                clip,

3980

                dpi_factor,

3981

                render_state.system_style.as_deref().map(|s| &s.colors),

3982

)?;

3983

3984

3985

        // BoxShadow

3986

        DisplayListItem::BoxShadow {

3987

176

            bounds,

3988

176

            shadow,

3989

176

            border_radius,

3990

        } => {

3991

176

            render_box_shadow(

3992

176

                pixmap,

3993

176

                &scroll_rect(bounds.inner()),

3994

176

                shadow,

3995

176

                border_radius,

3996

176

                dpi_factor,

3997

)?;

3998

3999

4000

        // --- Opacity layers ---

4001

        DisplayListItem::PushOpacity { bounds, opacity } => {

4002

            let rect = logical_rect_to_az_rect(&scroll_rect(bounds.inner()), dpi_factor);

4003

            if let Some(r) = rect {

4004

                let snap = snapshot_region(

4005

                    pixmap,

4006

                    r.x as i32,

4007

                    r.y as i32,

4008

                    r.width as u32,

4009

                    r.height as u32,

4010

);

4011

                mask_stack.push(MaskEntry::Opacity {

4012

                    snapshot: snap,

4013

                    rect: r,

4014

                    opacity: *opacity,

4015

});

4016

4017

4018

        DisplayListItem::PopOpacity => {

4019

            if let Some(MaskEntry::Opacity {

4020

                snapshot,

4021

                rect,

4022

                opacity,

4023

            }) = mask_stack.pop()

4024

4025

                let x = rect.x as i32;

4026

                let y = rect.y as i32;

4027

                let w = rect.width as u32;

4028

                let h = rect.height as u32;

4029

                let pw = pixmap.width as i32;

4030

                let ph = pixmap.height as i32;

4031

                // Blend: result = snapshot + (current - snapshot) * opacity

4032

                for py in 0..h as i32 {

4033

                    let dy = y + py;

4034

                    if dy < 0 || dy >= ph {

4035

                        continue;

4036

4037

                    for px in 0..w as i32 {

4038

                        let dx = x + px;

4039

                        if dx < 0 || dx >= pw {

4040

                            continue;

4041

4042

                        let pi = ((dy as u32 * pixmap.width + dx as u32) * 4) as usize;

4043

                        let si = ((py as u32 * w + px as u32) * 4) as usize;

4044

                        if pi + 3 >= pixmap.data.len() || si + 3 >= snapshot.len() {

4045

                            continue;

4046

4047

                        let op = (opacity * 255.0).clamp(0.0, 255.0) as u32;

4048

                        let inv_op = 255 - op;

4049

                        for c in 0..4 {

4050

                            let snap_c = snapshot[si + c] as u32;

4051

                            let cur_c = pixmap.data[pi + c] as u32;

4052

                            pixmap.data[pi + c] = ((cur_c * op + snap_c * inv_op) / 255) as u8;

4053

4054

4055

4056

4057

4058

4059

        // --- Reference frames (CSS transforms) ---

4060

        DisplayListItem::PushReferenceFrame {

4061

            transform_key,

4062

            initial_transform,

4063

            bounds,

4064

        } => {

4065

            // Look up the current GPU-cached transform value for this key.

4066

            // For scrollbar thumbs, the GpuValueCache stores the up-to-date

4067

            // thumb translation. For CSS transforms, it stores the computed

4068

            // matrix. Falls back to the initial_transform baked in the DL.

4069

            let live_transform = render_state.transforms.get(&transform_key.id);

4070

            let m = match live_transform {

4071

                Some(t) => &t.m,

4072

                None => &initial_transform.m,

4073

};

4074

            let tf = TransAffine::new_custom(

4075

                m[0][0] as f64,

4076

                m[0][1] as f64, // sx, shy

4077

                m[1][0] as f64,

4078

                m[1][1] as f64, // shx, sy

4079

                m[3][0] as f64,

4080

                m[3][1] as f64, // tx, ty

4081

);

4082

            let current = transform_stack

4083

                .last()

4084

                .cloned()

4085

                .unwrap_or_else(TransAffine::new);

4086

            let mut composed = tf;

4087

            composed.premultiply(&current);

4088

            transform_stack.push(composed);

4089

4090

        DisplayListItem::PopReferenceFrame => {

4091

            if transform_stack.len() > 1 {

4092

                transform_stack.pop();

4093

4094

4095

4096

        // --- Filter effects ---

4097

        // TODO: proper compositing architecture with per-layer pixbufs

4098

        DisplayListItem::PushFilter { .. } => {}

4099

        DisplayListItem::PopFilter => {}

4100

        DisplayListItem::PushBackdropFilter { .. } => {}

4101

        DisplayListItem::PopBackdropFilter => {}

4102

        DisplayListItem::PushTextShadow { .. } => {}

4103

        DisplayListItem::PopTextShadow => {}

4104

4105

        DisplayListItem::PushImageMaskClip {

4106

220

            bounds,

4107

220

            mask_image,

4108

220

            mask_rect,

4109

        } => {

4110

220

            let mr = &scroll_rect(mask_rect.inner());

4111

220

            let px_x = (mr.origin.x * dpi_factor) as i32;

4112

220

            let px_y = (mr.origin.y * dpi_factor) as i32;

4113

220

            let px_w = (mr.size.width * dpi_factor).ceil() as u32;

4114

220

            let px_h = (mr.size.height * dpi_factor).ceil() as u32;

4115

4116

220

            if px_w > 0 && px_h > 0 {

4117

220

                let snapshot = snapshot_region(pixmap, px_x, px_y, px_w, px_h);

4118

220

                let mask_data = extract_mask_data(mask_image, px_w, px_h)

4119

220

                    .unwrap_or_else(|| vec![255u8; (px_w * px_h) as usize]);

4120

220

                mask_stack.push(MaskEntry::ImageMask {

4121

220

                    snapshot,

4122

220

                    mask_data,

4123

220

                    origin_x: px_x,

4124

220

                    origin_y: px_y,

4125

220

                    width: px_w,

4126

220

                    height: px_h,

4127

220

});

4128

4129

4130

        DisplayListItem::PopImageMaskClip => {

4131

220

            if let Some(entry) = mask_stack.pop() {

4132

220

                apply_mask(pixmap, &entry);

4133

220

4134

4135

4136

4137

29700

    Ok(())

4138

29700

4139

4140

6512

fn render_rect(

4141

6512

    pixmap: &mut AzulPixmap,

4142

6512

    bounds: &LogicalRect,

4143

6512

    color: ColorU,

4144

6512

    border_radius: &BorderRadius,

4145

6512

    clip: Option<AzRect>,

4146

6512

    dpi_factor: f32,

4147

6512

) -> Result<(), String> {

4148

6512

    if color.a == 0 {

4149

        return Ok(());

4150

6512

4151

4152

6512

    let rect = match logical_rect_to_az_rect(bounds, dpi_factor) {

4153

6512

        Some(r) => r,

4154

        None => return Ok(()),

4155

};

4156

4157

    // Early-out if fully outside clip

4158

6512

    if let Some(ref c) = clip {

4159

1012

        if rect.clip(c).is_none() {

4160

748

            return Ok(());

4161

264

4162

5500

4163

4164

5764

    let agg_color = Rgba8::new(

4165

5764

        color.r as u32,

4166

5764

        color.g as u32,

4167

5764

        color.b as u32,

4168

5764

        color.a as u32,

4169

);

4170

4171

5764

    if border_radius.is_zero() {

4172

        // Fast path: axis-aligned rectangle — use direct RendererBase::blend_bar

4173

        // instead of the full rasterizer pipeline. This avoids path construction,

4174

        // cell generation, sorting, and scanline rendering for simple rectangles.

4175

5368

        let w = pixmap.width;

4176

5368

        let h = pixmap.height;

4177

5368

        let stride = (w * 4) as i32;

4178

5368

        let mut ra = unsafe { RowAccessor::new_with_buf(pixmap.data.as_mut_ptr(), w, h, stride) };

4179

5368

        let mut pf = PixfmtRgba32::new(&mut ra);

4180

5368

        let mut rb = RendererBase::new(pf);

4181

5368

        if let Some(c) = clip {

4182

264

            rb.clip_box_i(

4183

264

                c.x as i32,

4184

264

                c.y as i32,

4185

264

                (c.x + c.width) as i32 - 1,

4186

264

                (c.y + c.height) as i32 - 1,

4187

264

);

4188

5104

4189

5368

        rb.blend_bar(

4190

5368

            rect.x as i32,

4191

5368

            rect.y as i32,

4192

5368

            (rect.x + rect.width) as i32 - 1,

4193

5368

            (rect.y + rect.height) as i32 - 1,

4194

5368

            &agg_color,

4195

            255, // cover=255: alpha is already in the color

4196

);

4197

396

    } else {

4198

396

        // Rounded rect: needs the full rasterizer for curved corners

4199

396

        let mut path = build_rounded_rect_path(&rect, border_radius, dpi_factor);

4200

396

        agg_fill_path_clipped(pixmap, &mut path, &agg_color, FillingRule::NonZero, clip);

4201

396

4202

4203

5764

    Ok(())

4204

6512

4205

4206

5192

fn render_text(

4207

5192

    glyphs: &[GlyphInstance],

4208

5192

    font_hash: FontHash,

4209

5192

    font_size_px: f32,

4210

5192

    color: ColorU,

4211

5192

    pixmap: &mut AzulPixmap,

4212

5192

    clip_rect: &LogicalRect,

4213

5192

    clip: Option<AzRect>,

4214

5192

    renderer_resources: &RendererResources,

4215

5192

    font_manager: Option<&FontManager<FontRef>>,

4216

5192

    dpi_factor: f32,

4217

5192

    glyph_cache: &mut GlyphCache,

4218

5192

    scroll_offset: (f32, f32),

4219

5192

) -> Result<(), String> {

4220

5192

    if color.a == 0 || glyphs.is_empty() {

4221

        return Ok(());

4222

5192

4223

4224

    // Skip text entirely if its clip_rect is outside the active clip region

4225

5192

    if let Some(ref c) = clip {

4226

3520

        let text_rect = match logical_rect_to_az_rect(clip_rect, dpi_factor) {

4227

3520

            Some(r) => r,

4228

            None => return Ok(()),

4229

};

4230

3520

        if text_rect.clip(c).is_none() {

4231

3080

            return Ok(()); // fully clipped

4232

440

4233

1672

4234

4235

2112

    let agg_color = Rgba8::new(

4236

2112

        color.r as u32,

4237

2112

        color.g as u32,

4238

2112

        color.b as u32,

4239

2112

        color.a as u32,

4240

);

4241

4242

    // Try to get the parsed font

4243

2112

    let parsed_font: &ParsedFont = if let Some(fm) = font_manager {

4244

2112

        match fm.get_font_by_hash(font_hash.font_hash) {

4245

2112

            Some(font_ref) => unsafe { &*(font_ref.get_parsed() as *const ParsedFont) },

4246

            None => {

4247

                eprintln!(

4248

                    "[cpurender] Font hash {} not found in FontManager",

4249

                    font_hash.font_hash

4250

);

4251

                return Ok(());

4252

4253

4254

    } else {

4255

        let font_key = match renderer_resources.font_hash_map.get(&font_hash.font_hash) {

4256

            Some(k) => k,

4257

            None => {

4258

                eprintln!(

4259

                    "[cpurender] Font hash {} not found in font_hash_map (available: {:?})",

4260

                    font_hash.font_hash,

4261

                    renderer_resources.font_hash_map.keys().collect::<Vec<_>>()

4262

);

4263

                return Ok(());

4264

4265

};

4266

4267

        let font_ref = match renderer_resources.currently_registered_fonts.get(font_key) {

4268

            Some((font_ref, _instances)) => font_ref,

4269

            None => {

4270

                eprintln!(

4271

                    "[cpurender] FontKey {:?} not found in currently_registered_fonts",

4272

                    font_key

4273

);

4274

                return Ok(());

4275

4276

};

4277

4278

        unsafe { &*(font_ref.get_parsed() as *const ParsedFont) }

4279

};

4280

4281

2112

    let units_per_em = parsed_font.font_metrics.units_per_em as f32;

4282

2112

    if units_per_em <= 0.0 {

4283

        return Ok(());

4284

2112

4285

4286

2112

    let scale = (font_size_px * dpi_factor) / units_per_em;

4287

2112

    let ppem = (font_size_px * dpi_factor).round() as u16;

4288

4289

    // Set up the rasterizer pipeline once, reuse for all glyphs

4290

2112

    let w = pixmap.width;

4291

2112

    let h = pixmap.height;

4292

2112

    let stride = (w * 4) as i32;

4293

4294

    // Create renderer infrastructure once, reuse for all glyphs in this text run.

4295

    // Batches all glyph cells into a single rasterizer pass when possible.

4296

2112

    let mut ra = unsafe { RowAccessor::new_with_buf(pixmap.data.as_mut_ptr(), w, h, stride) };

4297

2112

    let mut pf = PixfmtRgba32::new(&mut ra);

4298

2112

    let mut rb = RendererBase::new(pf);

4299

2112

    if let Some(c) = clip {

4300

440

        rb.clip_box_i(

4301

440

            c.x as i32,

4302

440

            c.y as i32,

4303

440

            (c.x + c.width) as i32 - 1,

4304

440

            (c.y + c.height) as i32 - 1,

4305

440

);

4306

1672

4307

2112

    let mut ras = RasterizerScanlineAa::new();

4308

2112

    ras.filling_rule(FillingRule::NonZero);

4309

4310

    // Accumulate all glyph cells into one rasterizer, then render once.

4311

    // This amortizes sort_cells cost across all glyphs in the run.

4312

14960

    for glyph in glyphs {

4313

12848

        let glyph_index = glyph.index as u16;

4314

4315

        // Lazy decode: first access to a given gid for this face does

4316

        // the allsorts glyf walk + OwnedGlyph conversion; subsequent

4317

        // accesses are an Arc bump + BTreeMap lookup.

4318

12848

        let glyph_data = match parsed_font.get_or_decode_glyph(glyph_index) {

4319

12848

            Some(d) => d,

4320

            None => continue,

4321

};

4322

4323

12848

        let is_hinted = glyph_cache

4324

12848

            .get_or_build(

4325

12848

                font_hash.font_hash,

4326

12848

                glyph_index,

4327

12848

                &glyph_data,

4328

12848

                parsed_font,

4329

12848

                ppem,

4330

4331

12848

            .map(|c| c.is_hinted)

4332

12848

            .unwrap_or(false);

4333

4334

12848

        let glyph_x = (glyph.point.x - scroll_offset.0) * dpi_factor;

4335

12848

        let glyph_baseline_y = (glyph.point.y - scroll_offset.1) * dpi_factor;

4336

4337

12848

        let (cells, int_x, int_y) = match glyph_cache.get_or_build_cells(

4338

12848

            font_hash.font_hash,

4339

12848

            glyph_index,

4340

12848

            ppem,

4341

12848

            glyph_x,

4342

12848

            glyph_baseline_y,

4343

12848

            scale,

4344

12848

            is_hinted,

4345

12848

) {

4346

11968

            Some(c) => c,

4347

880

            None => continue,

4348

};

4349

4350

11968

        ras.add_cells_offset(cells, int_x, int_y);

4351

4352

4353

    // Single render pass for all glyphs in this text run

4354

2112

    let mut sl = ScanlineU8::new();

4355

2112

    render_scanlines_aa_solid(&mut ras, &mut sl, &mut rb, &agg_color);

4356

4357

2112

    Ok(())

4358

5192

4359

4360

4576

fn render_border(

4361

4576

    pixmap: &mut AzulPixmap,

4362

4576

    bounds: &LogicalRect,

4363

4576

    color: ColorU,

4364

4576

    width: f32,

4365

4576

    border_style: azul_css::props::style::border::BorderStyle,

4366

4576

    border_radius: &BorderRadius,

4367

4576

    clip: Option<AzRect>,

4368

4576

    dpi_factor: f32,

4369

4576

) -> Result<(), String> {

4370

    use azul_css::props::style::border::BorderStyle;

4371

4372

4576

    if color.a == 0 || width <= 0.0 {

4373

2772

        return Ok(());

4374

1804

4375

4376

1804

    match border_style {

4377

        BorderStyle::None | BorderStyle::Hidden => return Ok(()),

4378

1804

        _ => {}

4379

4380

4381

1804

    let rect = match logical_rect_to_az_rect(bounds, dpi_factor) {

4382

1804

        Some(r) => r,

4383

        None => return Ok(()),

4384

};

4385

4386

    // Skip if fully outside clip

4387

1804

    if let Some(ref c) = clip {

4388

880

        if rect.clip(c).is_none() {

4389

704

            return Ok(());

4390

176

4391

924

4392

4393

1100

    let scaled_width = width * dpi_factor;

4394

1100

    let agg_color = Rgba8::new(

4395

1100

        color.r as u32,

4396

1100

        color.g as u32,

4397

1100

        color.b as u32,

4398

1100

        color.a as u32,

4399

);

4400

4401

    // 1. Build outer path (rounded rect at the nominal border radii)

4402

1100

    let mut path = build_rounded_rect_path(&rect, border_radius, dpi_factor);

4403

4404

1100

    let x = rect.x as f64;

4405

1100

    let y = rect.y as f64;

4406

1100

    let w = rect.width as f64;

4407

1100

    let h = rect.height as f64;

4408

1100

    let sw = scaled_width as f64;

4409

4410

    // 2. Add inner path with shrunk radii so EvenOdd fill carves the stroke

4411

1100

    let ir = AzRect::from_xywh(

4412

1100

        rect.x + scaled_width,

4413

1100

        rect.y + scaled_width,

4414

1100

        rect.width - 2.0 * scaled_width,

4415

1100

        rect.height - 2.0 * scaled_width,

4416

);

4417

4418

1100

    if let Some(ir) = ir {

4419

1100

        let inner_radius = BorderRadius {

4420

1100

            top_left: (border_radius.top_left - width).max(0.0),

4421

1100

            top_right: (border_radius.top_right - width).max(0.0),

4422

1100

            bottom_right: (border_radius.bottom_right - width).max(0.0),

4423

1100

            bottom_left: (border_radius.bottom_left - width).max(0.0),

4424

1100

};

4425

1100

        let mut inner = build_rounded_rect_path(&ir, &inner_radius, dpi_factor);

4426

1100

        path.concat_path(&mut inner, 0);

4427

1100

4428

4429

    // 3. Render based on border style

4430

1100

    match border_style {

4431

        BorderStyle::Dashed | BorderStyle::Dotted => {

4432

            // For dashed/dotted: stroke the border path with dash pattern

4433

            use agg_rust::conv_dash::ConvDash;

4434

            use agg_rust::conv_stroke::ConvStroke;

4435

4436

            let half = sw / 2.0;

4437

            let mut stroke_path = PathStorage::new();

4438

            let (cx, cy, cw, ch) = (x + half, y + half, w - sw, h - sw);

4439

            stroke_path.move_to(cx, cy);

4440

            stroke_path.line_to(cx + cw, cy);

4441

            stroke_path.line_to(cx + cw, cy + ch);

4442

            stroke_path.line_to(cx, cy + ch);

4443

            stroke_path.close_polygon(PATH_FLAGS_NONE);

4444

4445

            let mut dashed = ConvDash::new(stroke_path);

4446

            if border_style == BorderStyle::Dashed {

4447

                dashed.add_dash(sw * 3.0, sw);

4448

            } else {

4449

                dashed.add_dash(sw, sw);

4450

4451

4452

            let mut stroked = ConvStroke::new(dashed);

4453

            stroked.set_width(sw);

4454

4455

            agg_fill_path_clipped(pixmap, &mut stroked, &agg_color, FillingRule::NonZero, clip);

4456

4457

1100

        _ if border_radius.is_zero() => {

4458

            // Fast path: solid border without rounding — use blend_bar strips

4459

1100

            let pw = pixmap.width;

4460

1100

            let ph = pixmap.height;

4461

1100

            let stride = (pw * 4) as i32;

4462

1100

            let mut ra =

4463

1100

                unsafe { RowAccessor::new_with_buf(pixmap.data.as_mut_ptr(), pw, ph, stride) };

4464

1100

            let mut pf = PixfmtRgba32::new(&mut ra);

4465

1100

            let mut rb = RendererBase::new(pf);

4466

1100

            if let Some(c) = clip {

4467

176

                rb.clip_box_i(

4468

176

                    c.x as i32,

4469

176

                    c.y as i32,

4470

176

                    (c.x + c.width) as i32 - 1,

4471

176

                    (c.y + c.height) as i32 - 1,

4472

176

);

4473

924

4474

1100

            let (xi, yi) = (x as i32, y as i32);

4475

1100

            let (x2i, y2i) = ((x + w) as i32 - 1, (y + h) as i32 - 1);

4476

1100

            let swi = sw as i32;

4477

            // Top strip

4478

1100

            rb.blend_bar(xi, yi, x2i, yi + swi - 1, &agg_color, 255);

4479

            // Bottom strip

4480

1100

            rb.blend_bar(xi, y2i - swi + 1, x2i, y2i, &agg_color, 255);

4481

            // Left strip (between top and bottom)

4482

1100

            rb.blend_bar(xi, yi + swi, xi + swi - 1, y2i - swi, &agg_color, 255);

4483

            // Right strip

4484

1100

            rb.blend_bar(x2i - swi + 1, yi + swi, x2i, y2i - swi, &agg_color, 255);

4485

4486

        _ => {

4487

            // Rounded solid border: fill double-path with EvenOdd

4488

            agg_fill_path_clipped(pixmap, &mut path, &agg_color, FillingRule::EvenOdd, clip);

4489

4490

4491

4492

1100

    Ok(())

4493

4576

4494

4495

/// Render border with per-side colors/widths/styles using CSS trapezoid model.

4496

/// Each side is a trapezoid: outer edge → inner edge with 45° miters at corners.

4497

fn render_border_sides(

4498

    pixmap: &mut AzulPixmap,

4499

    bounds: &LogicalRect,

4500

    colors: [ColorU; 4], // top, right, bottom, left

4501

    widths: [f32; 4],    // top, right, bottom, left

4502

    _styles: [azul_css::props::style::border::BorderStyle; 4],

4503

    _border_radius: &BorderRadius,

4504

    clip: Option<AzRect>,

4505

    dpi_factor: f32,

4506

) -> Result<(), String> {

4507

    let rect = match logical_rect_to_az_rect(bounds, dpi_factor) {

4508

        Some(r) => r,

4509

        None => return Ok(()),

4510

};

4511

4512

    // Outer corners

4513

    let ox = rect.x as f64;

4514

    let oy = rect.y as f64;

4515

    let ow = rect.width as f64;

4516

    let oh = rect.height as f64;

4517

4518

    // Inner corners (inset by per-side widths)

4519

    let wt = (widths[0] * dpi_factor) as f64;

4520

    let wr = (widths[1] * dpi_factor) as f64;

4521

    let wb = (widths[2] * dpi_factor) as f64;

4522

    let wl = (widths[3] * dpi_factor) as f64;

4523

4524

    let ix = ox + wl;

4525

    let iy = oy + wt;

4526

    let iw = ow - wl - wr;

4527

    let ih = oh - wt - wb;

4528

4529

    // Each side is a trapezoid with 4 vertices:

4530

    // Top:    (ox, oy) → (ox+ow, oy) → (ix+iw, iy) → (ix, iy)

4531

    // Right:  (ox+ow, oy) → (ox+ow, oy+oh) → (ix+iw, iy+ih) → (ix+iw, iy)

4532

    // Bottom: (ox+ow, oy+oh) → (ox, oy+oh) → (ix, iy+ih) → (ix+iw, iy+ih)

4533

    // Left:   (ox, oy+oh) → (ox, oy) → (ix, iy) → (ix, iy+ih)

4534

4535

    let sides: [(f64, f64, f64, f64, f64, f64, f64, f64, ColorU, f32); 4] = [

4536

        // Top trapezoid

4537

4538

ox,

4539

oy,

4540

            ox + ow,

4541

oy,

4542

            ix + iw,

4543

iy,

4544

ix,

4545

iy,

4546

            colors[0],

4547

            widths[0],

4548

),

4549

        // Right trapezoid

4550

4551

            ox + ow,

4552

oy,

4553

            ox + ow,

4554

            oy + oh,

4555

            ix + iw,

4556

            iy + ih,

4557

            ix + iw,

4558

iy,

4559

            colors[1],

4560

            widths[1],

4561

),

4562

        // Bottom trapezoid

4563

4564

            ox + ow,

4565

            oy + oh,

4566

ox,

4567

            oy + oh,

4568

ix,

4569

            iy + ih,

4570

            ix + iw,

4571

            iy + ih,

4572

            colors[2],

4573

            widths[2],

4574

),

4575

        // Left trapezoid

4576

4577

ox,

4578

            oy + oh,

4579

ox,

4580

oy,

4581

ix,

4582

iy,

4583

ix,

4584

            iy + ih,

4585

            colors[3],

4586

            widths[3],

4587

),

4588

];

4589

4590

    if _border_radius.is_zero() {

4591

        // Fast path: axis-aligned border strips — no rasterizer needed

4592

        let pw = pixmap.width;

4593

        let ph = pixmap.height;

4594

        let stride = (pw * 4) as i32;

4595

        let mut ra = unsafe { RowAccessor::new_with_buf(pixmap.data.as_mut_ptr(), pw, ph, stride) };

4596

        let mut pf = PixfmtRgba32::new(&mut ra);

4597

        let mut rb = RendererBase::new(pf);

4598

        if let Some(c) = clip {

4599

            rb.clip_box_i(

4600

                c.x as i32,

4601

                c.y as i32,

4602

                (c.x + c.width) as i32 - 1,

4603

                (c.y + c.height) as i32 - 1,

4604

);

4605

4606

        // Top: full width, height = wt

4607

        if widths[0] > 0.0 && colors[0].a > 0 {

4608

            let c = colors[0];

4609

            let ac = Rgba8::new(c.r as u32, c.g as u32, c.b as u32, c.a as u32);

4610

            rb.blend_bar(

4611

                ox as i32,

4612

                oy as i32,

4613

                (ox + ow) as i32 - 1,

4614

                iy as i32 - 1,

4615

                &ac,

4616

                255,

4617

);

4618

4619

        // Bottom

4620

        if widths[2] > 0.0 && colors[2].a > 0 {

4621

            let c = colors[2];

4622

            let ac = Rgba8::new(c.r as u32, c.g as u32, c.b as u32, c.a as u32);

4623

            rb.blend_bar(

4624

                ox as i32,

4625

                (iy + ih) as i32,

4626

                (ox + ow) as i32 - 1,

4627

                (oy + oh) as i32 - 1,

4628

                &ac,

4629

                255,

4630

);

4631

4632

        // Left: between top and bottom

4633

        if widths[3] > 0.0 && colors[3].a > 0 {

4634

            let c = colors[3];

4635

            let ac = Rgba8::new(c.r as u32, c.g as u32, c.b as u32, c.a as u32);

4636

            rb.blend_bar(

4637

                ox as i32,

4638

                iy as i32,

4639

                ix as i32 - 1,

4640

                (iy + ih) as i32 - 1,

4641

                &ac,

4642

                255,

4643

);

4644

4645

        // Right

4646

        if widths[1] > 0.0 && colors[1].a > 0 {

4647

            let c = colors[1];

4648

            let ac = Rgba8::new(c.r as u32, c.g as u32, c.b as u32, c.a as u32);

4649

            rb.blend_bar(

4650

                (ix + iw) as i32,

4651

                iy as i32,

4652

                (ox + ow) as i32 - 1,

4653

                (iy + ih) as i32 - 1,

4654

                &ac,

4655

                255,

4656

);

4657

4658

    } else {

4659

        // Rounded borders: use trapezoid rasterizer

4660

        for &(x0, y0, x1, y1, x2, y2, x3, y3, color, width) in &sides {

4661

            if width <= 0.0 || color.a == 0 {

4662

                continue;

4663

4664

4665

            let mut path = PathStorage::new();

4666

            path.move_to(x0, y0);

4667

            path.line_to(x1, y1);

4668

            path.line_to(x2, y2);

4669

            path.line_to(x3, y3);

4670

            path.close_polygon(PATH_FLAGS_NONE);

4671

4672

            let agg_color = Rgba8::new(

4673

                color.r as u32,

4674

                color.g as u32,

4675

                color.b as u32,

4676

                color.a as u32,

4677

);

4678

            agg_fill_path_clipped(pixmap, &mut path, &agg_color, FillingRule::NonZero, clip);

4679

4680

4681

4682

    Ok(())

4683

4684

4685

12628

fn logical_rect_to_az_rect(bounds: &LogicalRect, dpi_factor: f32) -> Option<AzRect> {

4686

12628

    let x = bounds.origin.x * dpi_factor;

4687

12628

    let y = bounds.origin.y * dpi_factor;

4688

12628

    let width = bounds.size.width * dpi_factor;

4689

12628

    let height = bounds.size.height * dpi_factor;

4690

4691

12628

    AzRect::from_xywh(x, y, width, height)

4692

12628

4693

4694

132

fn render_image(

4695

132

    pixmap: &mut AzulPixmap,

4696

132

    bounds: &LogicalRect,

4697

132

    image: &ImageRef,

4698

132

    clip: Option<AzRect>,

4699

132

    dpi_factor: f32,

4700

132

) -> Result<(), String> {

4701

132

    let rect = match logical_rect_to_az_rect(bounds, dpi_factor) {

4702

132

        Some(r) => r,

4703

        None => return Ok(()),

4704

};

4705

4706

    // Skip if fully outside clip

4707

132

    if let Some(ref c) = clip {

4708

        if rect.clip(c).is_none() {

4709

            return Ok(());

4710

4711

132

4712

4713

132

    let image_data = image.get_data();

4714

132

    let (src_rgba, src_w, src_h) = match &*image_data {

4715

132

        DecodedImage::Raw((descriptor, data)) => {

4716

132

            let w = descriptor.width as u32;

4717

132

            let h = descriptor.height as u32;

4718

132

            if w == 0 || h == 0 {

4719

                return Ok(());

4720

132

4721

132

            let bytes = match data {

4722

132

                azul_core::resources::ImageData::Raw(shared) => shared.as_ref(),

4723

                _ => return Ok(()),

4724

};

4725

4726

132

            let rgba = match descriptor.format {

4727

                azul_core::resources::RawImageFormat::BGRA8 => {

4728

132

                    let mut out = Vec::with_capacity(bytes.len());

4729

1320000

                    for chunk in bytes.chunks_exact(4) {

4730

1320000

                        let b = chunk[0];

4731

1320000

                        let g = chunk[1];

4732

1320000

                        let r = chunk[2];

4733

1320000

                        let a = chunk[3];

4734

1320000

                        out.push(r);

4735

1320000

                        out.push(g);

4736

1320000

                        out.push(b);

4737

1320000

                        out.push(a);

4738

1320000

4739

132

out

4740

4741

                azul_core::resources::RawImageFormat::R8 => {

4742

                    let mut out = Vec::with_capacity(bytes.len() * 4);

4743

                    for &v in bytes {

4744

                        out.push(v);

4745

                        out.push(v);

4746

                        out.push(v);

4747

                        out.push(v);

4748

4749

out

4750

4751

                _ => {

4752

                    // Unsupported format — render gray placeholder

4753

                    let gray = Rgba8::new(200, 200, 200, 255);

4754

                    let mut path = build_rect_path(&rect);

4755

                    agg_fill_path(pixmap, &mut path, &gray, FillingRule::NonZero);

4756

                    return Ok(());

4757

4758

};

4759

4760

132

            (rgba, w, h)

4761

4762

        DecodedImage::NullImage { .. } | DecodedImage::Callback(_) => {

4763

            let gray = Rgba8::new(200, 200, 200, 255);

4764

            let mut path = build_rect_path(&rect);

4765

            agg_fill_path(pixmap, &mut path, &gray, FillingRule::NonZero);

4766

            return Ok(());

4767

4768

        _ => return Ok(()),

4769

};

4770

4771

    // Simple nearest-neighbor blit with scaling

4772

132

    let dst_x = rect.x as i32;

4773

132

    let dst_y = rect.y as i32;

4774

132

    let dst_w = rect.width as u32;

4775

132

    let dst_h = rect.height as u32;

4776

132

    let pw = pixmap.width;

4777

132

    let ph = pixmap.height;

4778

4779

132

    let sx = src_w as f32 / dst_w.max(1) as f32;

4780

132

    let sy = src_h as f32 / dst_h.max(1) as f32;

4781

4782

    // Compute pixel-level clip bounds for the blit loop

4783

132

    let (clip_x1, clip_y1, clip_x2, clip_y2) = if let Some(ref c) = clip {

4784

4785

            c.x as i32,

4786

            c.y as i32,

4787

            (c.x + c.width) as i32,

4788

            (c.y + c.height) as i32,

4789

4790

    } else {

4791

132

        (0, 0, pw as i32, ph as i32)

4792

};

4793

4794

11440

    for py in 0..dst_h {

4795

1038400

        for px in 0..dst_w {

4796

1038400

            let tx = dst_x + px as i32;

4797

1038400

            let ty = dst_y + py as i32;

4798

1038400

            if tx < 0 || ty < 0 || tx >= pw as i32 || ty >= ph as i32 {

4799

                continue;

4800

1038400

4801

            // Clip check

4802

1038400

            if tx < clip_x1 || ty < clip_y1 || tx >= clip_x2 || ty >= clip_y2 {

4803

                continue;

4804

1038400

4805

4806

1038400

            let src_x = ((px as f32 * sx) as u32).min(src_w - 1);

4807

1038400

            let src_y = ((py as f32 * sy) as u32).min(src_h - 1);

4808

1038400

            let si = ((src_y * src_w + src_x) * 4) as usize;

4809

1038400

            let di = ((ty as u32 * pw + tx as u32) * 4) as usize;

4810

4811

1038400

            if si + 3 < src_rgba.len() && di + 3 < pixmap.data.len() {

4812

1038400

                let sa = src_rgba[si + 3] as u32;

4813

1038400

                if sa == 255 {

4814

1038400

                    pixmap.data[di] = src_rgba[si];

4815

1038400

                    pixmap.data[di + 1] = src_rgba[si + 1];

4816

1038400

                    pixmap.data[di + 2] = src_rgba[si + 2];

4817

1038400

                    pixmap.data[di + 3] = 255;

4818

1038400

                } else if sa > 0 {

4819

                    // Alpha blend: dst = src * sa + dst * (255 - sa)

4820

                    let da = 255 - sa;

4821

                    pixmap.data[di] =

4822

                        ((src_rgba[si] as u32 * sa + pixmap.data[di] as u32 * da) / 255) as u8;

4823

                    pixmap.data[di + 1] = ((src_rgba[si + 1] as u32 * sa

4824

                        + pixmap.data[di + 1] as u32 * da)

4825

                        / 255) as u8;

4826

                    pixmap.data[di + 2] = ((src_rgba[si + 2] as u32 * sa

4827

                        + pixmap.data[di + 2] as u32 * da)

4828

                        / 255) as u8;

4829

                    pixmap.data[di + 3] =

4830

                        ((sa + pixmap.data[di + 3] as u32 * da / 255).min(255)) as u8;

4831

4832

4833

4834

4835

4836

132

    Ok(())

4837

132

4838

4839

220

fn build_rect_path(rect: &AzRect) -> PathStorage {

4840

220

    let mut path = PathStorage::new();

4841

220

    let x = rect.x as f64;

4842

220

    let y = rect.y as f64;

4843

220

    let w = rect.width as f64;

4844

220

    let h = rect.height as f64;

4845

220

    path.move_to(x, y);

4846

220

    path.line_to(x + w, y);

4847

220

    path.line_to(x + w, y + h);

4848

220

    path.line_to(x, y + h);

4849

220

    path.close_polygon(PATH_FLAGS_NONE);

4850

220

    path

4851

220

4852

4853

2596

fn build_rounded_rect_path(

4854

2596

    rect: &AzRect,

4855

2596

    border_radius: &BorderRadius,

4856

2596

    dpi_factor: f32,

4857

2596

) -> PathStorage {

4858

2596

    let mut path = PathStorage::new();

4859

4860

2596

    let x = rect.x as f64;

4861

2596

    let y = rect.y as f64;

4862

2596

    let w = rect.width as f64;

4863

2596

    let h = rect.height as f64;

4864

4865

2596

    let tl = (border_radius.top_left * dpi_factor) as f64;

4866

2596

    let tr = (border_radius.top_right * dpi_factor) as f64;

4867

2596

    let br = (border_radius.bottom_right * dpi_factor) as f64;

4868

2596

    let bl = (border_radius.bottom_left * dpi_factor) as f64;

4869

4870

2596

    if tl <= 0.0 && tr <= 0.0 && br <= 0.0 && bl <= 0.0 {

4871

2200

        path.move_to(x, y);

4872

2200

        path.line_to(x + w, y);

4873

2200

        path.line_to(x + w, y + h);

4874

2200

        path.line_to(x, y + h);

4875

2200

        path.close_polygon(PATH_FLAGS_NONE);

4876

2200

        return path;

4877

396

4878

4879

    // agg::RoundedRect emits real arc vertices (MOVE_TO + LINE_TO segments)

4880

    // via its embedded Arc generator, which the scanline rasterizer consumes

4881

    // directly. curve3() control points are silently flattened to straight

4882

    // lines by the rasterizer, which is why the hand-rolled path produced

4883

    // square corners — Arc-based flattening produces smooth corners.

4884

//

4885

    // agg's corner slots (rx1/ry1 .. rx4/ry4) map to screen corners as:

4886

    //   slot 1 → top-left    (center at x1+rx1, y1+ry1)

4887

    //   slot 2 → top-right   (center at x2-rx2, y1+ry2)

4888

    //   slot 3 → bottom-right (center at x2-rx3, y2-ry3)

4889

    //   slot 4 → bottom-left (center at x1+rx4, y2-ry4)

4890

396

    let mut rr = RoundedRect::default_new();

4891

396

    rr.rect(x, y, x + w, y + h);

4892

396

    rr.radius_all(tl, tl, tr, tr, br, br, bl, bl);

4893

396

    rr.normalize_radius();

4894

396

    rr.set_approximation_scale(dpi_factor.max(1.0) as f64);

4895

4896

396

    path.concat_path(&mut rr, 0);

4897

396

    path

4898

2596

4899

4900

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

4901

// Component Preview Rendering

4902

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

4903

4904

/// Options for rendering a component preview.

4905

pub struct ComponentPreviewOptions {

4906

    /// Optional width constraint. If None, size to content (uses 4096px max).

4907

    pub width: Option<f32>,

4908

    /// Optional height constraint. If None, size to content (uses 4096px max).

4909

    pub height: Option<f32>,

4910

    /// DPI scale factor. Default 1.0.

4911

    pub dpi_factor: f32,

4912

    /// Background color. Default white.

4913

    pub background_color: ColorU,

4914

4915

4916

impl Default for ComponentPreviewOptions {

4917

    fn default() -> Self {

4918

        Self {

4919

            width: None,

4920

            height: None,

4921

            dpi_factor: 1.0,

4922

            background_color: ColorU {

4923

                r: 255,

4924

                g: 255,

4925

                b: 255,

4926

                a: 255,

4927

},

4928

4929

4930

4931

4932

/// Result of a component preview render.

4933

pub struct ComponentPreviewResult {

4934

    /// PNG-encoded image data.

4935

    pub png_data: Vec<u8>,

4936

    /// Actual content width (logical pixels).

4937

    pub content_width: f32,

4938

    /// Actual content height (logical pixels).

4939

    pub content_height: f32,

4940

4941

4942

/// Compute the tight bounding box of all display list items.

4943

fn compute_content_bounds(dl: &DisplayList) -> Option<(f32, f32, f32, f32)> {

4944

    let mut min_x = f32::MAX;

4945

    let mut min_y = f32::MAX;

4946

    let mut max_x = f32::MIN;

4947

    let mut max_y = f32::MIN;

4948

    let mut has_items = false;

4949

4950

    for item in &dl.items {

4951

        let bounds = match item {

4952

            DisplayListItem::Rect { bounds, .. } => Some(*bounds),

4953

            DisplayListItem::SelectionRect { bounds, .. } => Some(*bounds),

4954

            DisplayListItem::Border { bounds, .. } => Some(*bounds),

4955

            DisplayListItem::Text { clip_rect, .. } => Some(*clip_rect),

4956

            DisplayListItem::Image { bounds, .. } => Some(*bounds),

4957

            DisplayListItem::BoxShadow { bounds, .. } => Some(*bounds),

4958

            DisplayListItem::PushClip { bounds, .. } => Some(*bounds),

4959

            DisplayListItem::LinearGradient { bounds, .. } => Some(*bounds),

4960

            DisplayListItem::RadialGradient { bounds, .. } => Some(*bounds),

4961

            DisplayListItem::ConicGradient { bounds, .. } => Some(*bounds),

4962

            DisplayListItem::VirtualView { bounds, .. } => Some(*bounds),

4963

            DisplayListItem::ScrollBar { bounds, .. } => Some(*bounds),

4964

            _ => None,

4965

};

4966

        if let Some(b) = bounds {

4967

            has_items = true;

4968

            min_x = min_x.min(b.0.origin.x);

4969

            min_y = min_y.min(b.0.origin.y);

4970

            max_x = max_x.max(b.0.origin.x + b.0.size.width);

4971

            max_y = max_y.max(b.0.origin.y + b.0.size.height);

4972

4973

4974

4975

    if has_items {

4976

        Some((min_x, min_y, max_x, max_y))

4977

    } else {

4978

        None

4979

4980

4981

4982

/// Render a `StyledDom` to a PNG image for component preview.

4983

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

4984

748

pub fn render_component_preview(

4985

748

    styled_dom: azul_core::styled_dom::StyledDom,

4986

748

    font_manager: &FontManager<azul_css::props::basic::FontRef>,

4987

748

    opts: ComponentPreviewOptions,

4988

748

    system_style: Option<std::sync::Arc<azul_css::system::SystemStyle>>,

4989

748

) -> Result<ComponentPreviewResult, String> {

4990

    use crate::{

4991

        font_traits::TextLayoutCache,

4992

        solver3::{self, cache::LayoutCache, display_list::DisplayList},

4993

};

4994

    use azul_core::{

4995

        dom::DomId,

4996

        geom::{LogicalPosition, LogicalRect, LogicalSize},

4997

        resources::{IdNamespace, RendererResources},

4998

        selection::{SelectionState, TextSelection},

4999

};

5000

    use std::collections::{BTreeMap, HashMap};

5001

5002

    const MAX_SIZE: f32 = 4096.0;

5003

5004

748

    let layout_width = opts.width.unwrap_or(MAX_SIZE);

5005

748

    let layout_height = opts.height.unwrap_or(MAX_SIZE);

5006

5007

748

    let viewport = LogicalRect {

5008

748

        origin: LogicalPosition::zero(),

5009

748

        size: LogicalSize {

5010

748

            width: layout_width,

5011

748

            height: layout_height,

5012

748

},

5013

748

};

5014

5015

748

    let mut preview_font_manager = FontManager::from_arc_shared(

5016

748

        font_manager.fc_cache.clone(),

5017

748

        font_manager.parsed_fonts.clone(),

5018

5019

748

    .map_err(|e| format!("Failed to create preview font manager: {:?}", e))?;

5020

5021

    // --- Font resolution ---

5022

5023

        use crate::solver3::getters::collect_and_resolve_font_chains_with_registration;

5024

        use crate::text3::default::PathLoader;

5025

5026

748

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

5027

5028

748

        let chains = collect_and_resolve_font_chains_with_registration(

5029

748

            &styled_dom,

5030

748

            &preview_font_manager.fc_cache,

5031

748

            &preview_font_manager,

5032

748

            &platform,

5033

);

5034

748

        let loader = PathLoader::new();

5035

748

        let _failed = preview_font_manager.load_missing_for_chains(&chains, |bytes, index| {

5036

            loader.load_font_shared(bytes, index)

5037

});

5038

748

        preview_font_manager.set_font_chain_cache(chains.into_fontconfig_chains());

5039

5040

5041

    // --- Layout ---

5042

748

    let mut layout_cache = LayoutCache {

5043

748

        tree: None,

5044

748

        calculated_positions: Vec::new(),

5045

748

        viewport: None,

5046

748

        scroll_ids: HashMap::new(),

5047

748

        scroll_id_to_node_id: HashMap::new(),

5048

748

        counters: HashMap::new(),

5049

748

        float_cache: HashMap::new(),

5050

748

        cache_map: Default::default(),

5051

748

        previous_positions: Vec::new(),

5052

748

        cached_display_list: None,

5053

748

        prev_dom_ptr: 0,

5054

748

        prev_viewport: LogicalRect::zero(),

5055

748

};

5056

748

    let mut text_cache = TextLayoutCache::new();

5057

748

    let empty_scroll_offsets = BTreeMap::new();

5058

748

    let empty_text_selections = BTreeMap::new();

5059

748

    let renderer_resources = RendererResources::default();

5060

748

    let id_namespace = IdNamespace(0xFFFF);

5061

748

    let dom_id = DomId::ROOT_ID;

5062

748

    let mut debug_messages = None;

5063

748

    let get_system_time_fn = azul_core::task::GetSystemTimeCallback {

5064

748

        cb: azul_core::task::get_system_time_libstd,

5065

748

};

5066

5067

748

    let display_list = solver3::layout_document(

5068

748

        &mut layout_cache,

5069

748

        &mut text_cache,

5070

748

        &styled_dom,

5071

748

        viewport,

5072

748

        &preview_font_manager,

5073

748

        &empty_scroll_offsets,

5074

748

        &empty_text_selections,

5075

748

        &mut debug_messages,

5076

748

        None,

5077

748

        &renderer_resources,

5078

748

        id_namespace,

5079

748

        dom_id,

5080

        false,

5081

748

        Vec::new(),

5082

748

        None, // preedit_text: not needed for headless preview rendering

5083

748

        &azul_core::resources::ImageCache::default(),

5084

748

        system_style.clone(),

5085

748

        get_system_time_fn,

5086

5087

748

    .map_err(|e| format!("Layout failed: {:?}", e))?;

5088

5089

    // --- Determine actual render size ---

5090

748

    let (render_width, render_height) = if opts.width.is_some() && opts.height.is_some() {

5091

748

        (opts.width.unwrap(), opts.height.unwrap())

5092

    } else {

5093

        match compute_content_bounds(&display_list) {

5094

            Some((_min_x, _min_y, max_x, max_y)) => {

5095

                let w = if opts.width.is_some() {

5096

                    opts.width.unwrap()

5097

                } else {

5098

                    max_x.max(1.0).ceil()

5099

};

5100

                let h = if opts.height.is_some() {

5101

                    opts.height.unwrap()

5102

                } else {

5103

                    max_y.max(1.0).ceil()

5104

};

5105

                (w, h)

5106

5107

            None => {

5108

                return Ok(ComponentPreviewResult {

5109

                    png_data: Vec::new(),

5110

                    content_width: 0.0,

5111

                    content_height: 0.0,

5112

});

5113

5114

5115

};

5116

5117

748

    let render_width = render_width.min(MAX_SIZE);

5118

748

    let render_height = render_height.min(MAX_SIZE);

5119

5120

    // --- Render ---

5121

748

    let dpi = opts.dpi_factor;

5122

748

    let pixel_w = ((render_width * dpi) as u32).max(1);

5123

748

    let pixel_h = ((render_height * dpi) as u32).max(1);

5124

5125

748

    let mut pixmap = AzulPixmap::new(pixel_w, pixel_h)

5126

748

        .ok_or_else(|| format!("Cannot create pixmap {}x{}", pixel_w, pixel_h))?;

5127

5128

748

    let bg = opts.background_color;

5129

748

    pixmap.fill(bg.r, bg.g, bg.b, bg.a);

5130

5131

748

    let mut preview_glyph_cache = GlyphCache::new();

5132

748

    let preview_render_state =

5133

748

        CpuRenderState::new(ScrollOffsetMap::new()).with_system_style(system_style);

5134

748

    render_display_list_with_state(

5135

748

        &display_list,

5136

748

        &mut pixmap,

5137

748

        dpi,

5138

748

        &renderer_resources,

5139

748

        Some(&preview_font_manager),

5140

748

        &mut preview_glyph_cache,

5141

748

        &preview_render_state,

5142

)?;

5143

5144

748

    let png_data = pixmap

5145

748

        .encode_png()

5146

748

        .map_err(|e| format!("PNG encoding failed: {}", e))?;

5147

5148

748

    Ok(ComponentPreviewResult {

5149

748

        png_data,

5150

748

        content_width: render_width,

5151

748

        content_height: render_height,

5152

748

})

5153

748

5154

5155

/// Render a `Dom` + `Css` to a PNG image at the given dimensions.

5156

///

5157

/// This is a convenience API that creates a `StyledDom`, lays it out,

5158

/// and rasterizes via the CPU renderer.

5159

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

5160

748

pub fn render_dom_to_image(

5161

748

    mut dom: azul_core::dom::Dom,

5162

748

    css: azul_css::css::Css,

5163

748

    width: f32,

5164

748

    height: f32,

5165

748

    dpi: f32,

5166

748

) -> Result<Vec<u8>, String> {

5167

    use crate::font_traits::FontManager;

5168

    use azul_core::styled_dom::StyledDom;

5169

5170

748

    let styled_dom = StyledDom::create(&mut dom, css);

5171

5172

748

    let fc_cache = crate::font::loading::build_font_cache();

5173

748

    let font_manager = FontManager::new(fc_cache)

5174

748

        .map_err(|e| format!("Failed to create font manager: {:?}", e))?;

5175

5176

748

    let opts = ComponentPreviewOptions {

5177

748

        width: Some(width),

5178

748

        height: Some(height),

5179

748

        dpi_factor: dpi,

5180

748

        background_color: azul_css::props::basic::ColorU {

5181

748

            r: 255,

5182

748

            g: 255,

5183

748

            b: 255,

5184

748

            a: 255,

5185

748

},

5186

748

};

5187

5188

748

    let result = render_component_preview(styled_dom, &font_manager, opts, None)?;

5189

748

    Ok(result.png_data)

5190

748

5191

5192

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

5193

// Direct SVG-to-image renderer (bypasses CSS layout)

5194

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

5195

5196

/// Render raw SVG bytes to a PNG image.

5197

///

5198

/// Parses the SVG XML, walks the element tree, extracts path geometry +

5199

/// fill/stroke attributes, and rasterizes via agg-rust directly (no CSS

5200

/// layout involved).

5201

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

5202

88

pub fn render_svg_to_png(

5203

88

    svg_data: &[u8],

5204

88

    target_width: u32,

5205

88

    target_height: u32,

5206

88

) -> Result<Vec<u8>, String> {

5207

88

    let svg_str =

5208

88

        core::str::from_utf8(svg_data).map_err(|e| format!("SVG is not valid UTF-8: {e}"))?;

5209

5210

88

    let nodes =

5211

88

        crate::xml::parse_xml_string(svg_str).map_err(|e| format!("XML parse error: {e}"))?;

5212

5213

    // Find the <svg> root

5214

88

    let node_slice: &[azul_core::xml::XmlNodeChild] = nodes.as_ref();

5215

88

    let svg_node = node_slice

5216

88

        .iter()

5217

88

        .find_map(|n| {

5218

88

            if let azul_core::xml::XmlNodeChild::Element(e) = n {

5219

88

                let tag = e.node_type.as_str().to_lowercase();

5220

88

                if tag == "svg" {

5221

88

                    Some(e)

5222

                } else {

5223

                    None

5224

5225

            } else {

5226

                None

5227

5228

88

})

5229

88

        .ok_or_else(|| "No <svg> root element found".to_string())?;

5230

5231

    // Parse viewBox for coordinate mapping

5232

88

    let vb = parse_viewbox(svg_node);

5233

88

    let (vb_x, vb_y, vb_w, vb_h) =

5234

88

        vb.unwrap_or((0.0, 0.0, target_width as f64, target_height as f64));

5235

5236

88

    let sx = target_width as f64 / vb_w;

5237

88

    let sy = target_height as f64 / vb_h;

5238

88

    let scale = sx.min(sy);

5239

5240

88

    let root_transform =

5241

88

        TransAffine::new_custom(scale, 0.0, 0.0, scale, -vb_x * scale, -vb_y * scale);

5242

5243

88

    let mut pixmap = AzulPixmap::new(target_width, target_height)

5244

88

        .ok_or_else(|| "Failed to create pixmap".to_string())?;

5245

88

    pixmap.fill(255, 255, 255, 255);

5246

5247

88

    render_svg_group(svg_node, &mut pixmap, &root_transform);

5248

5249

88

    pixmap

5250

88

        .encode_png()

5251

88

        .map_err(|e| format!("PNG encode error: {e}"))

5252

88

5253

5254

/// Like [`render_svg_to_png`] but returns the rendered pixmap as an [`ImageRef`]

5255

/// (RGBA8) directly — no PNG round-trip. The MapWidget uses this to render each

5256

/// decoded tile SVG to a colour image node: `SvgNodeData::Path` in the DOM only

5257

/// produces a clip mask (not a filled shape), so reuse the same `render_svg_group`

5258

/// rasteriser the tiger uses (which reads SVG fill/stroke attrs) and embed the

5259

/// result as an image.

5260

pub fn render_svg_to_imageref(

5261

    svg_data: &[u8],

5262

    target_width: u32,

5263

    target_height: u32,

5264

) -> Result<ImageRef, String> {

5265

    let svg_str =

5266

        core::str::from_utf8(svg_data).map_err(|e| format!("SVG is not valid UTF-8: {e}"))?;

5267

    let nodes =

5268

        crate::xml::parse_xml_string(svg_str).map_err(|e| format!("XML parse error: {e}"))?;

5269

    let node_slice: &[azul_core::xml::XmlNodeChild] = nodes.as_ref();

5270

    let svg_node = node_slice

5271

        .iter()

5272

        .find_map(|n| {

5273

            if let azul_core::xml::XmlNodeChild::Element(e) = n {

5274

                if e.node_type.as_str().to_lowercase() == "svg" {

5275

                    Some(e)

5276

                } else {

5277

                    None

5278

5279

            } else {

5280

                None

5281

5282

})

5283

        .ok_or_else(|| "No <svg> root element found".to_string())?;

5284

5285

    let vb = parse_viewbox(svg_node);

5286

    let (vb_x, vb_y, vb_w, vb_h) =

5287

        vb.unwrap_or((0.0, 0.0, target_width as f64, target_height as f64));

5288

    let scale = (target_width as f64 / vb_w).min(target_height as f64 / vb_h);

5289

    let root_transform =

5290

        TransAffine::new_custom(scale, 0.0, 0.0, scale, -vb_x * scale, -vb_y * scale);

5291

5292

    let mut pixmap = AzulPixmap::new(target_width, target_height)

5293

        .ok_or_else(|| "Failed to create pixmap".to_string())?;

5294

    // Transparent background so the tile container shows through any gaps.

5295

    pixmap.fill(0, 0, 0, 0);

5296

    render_svg_group(svg_node, &mut pixmap, &root_transform);

5297

5298

    let rgba = pixmap.data().to_vec();

5299

    let raw = azul_core::resources::RawImage {

5300

        pixels: azul_core::resources::RawImageData::U8(rgba.into()),

5301

        width: target_width as usize,

5302

        height: target_height as usize,

5303

        premultiplied_alpha: false,

5304

        data_format: azul_core::resources::RawImageFormat::RGBA8,

5305

        tag: alloc::vec::Vec::new().into(),

5306

};

5307

    ImageRef::new_rawimage(raw).ok_or_else(|| "Failed to build ImageRef from pixmap".to_string())

5308

5309

5310

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

5311

88

fn parse_viewbox(node: &azul_core::xml::XmlNode) -> Option<(f64, f64, f64, f64)> {

5312

88

    let vb = node

5313

88

        .attributes

5314

88

        .get_key("viewbox")

5315

88

        .or_else(|| node.attributes.get_key("viewBox"))?;

5316

88

    let nums: Vec<f64> = vb

5317

88

        .as_str()

5318

1364

        .split(|c: char| c == ',' || c.is_ascii_whitespace())

5319

352

        .filter(|s| !s.is_empty())

5320

352

        .filter_map(|s| s.parse().ok())

5321

88

        .collect();

5322

88

    if nums.len() == 4 {

5323

88

        Some((nums[0], nums[1], nums[2], nums[3]))

5324

    } else {

5325

        None

5326

5327

88

5328

5329

/// Inherited SVG style (fill, stroke, stroke-width) that cascades from parent groups.

5330

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

5331

#[derive(Clone)]

5332

struct SvgInheritedStyle {

5333

    fill: Option<String>,   // None = not set (inherit default black)

5334

    stroke: Option<String>, // None = not set (inherit default none)

5335

    stroke_width: Option<f64>,

5336

5337

5338

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

5339

impl Default for SvgInheritedStyle {

5340

88

    fn default() -> Self {

5341

88

        Self {

5342

88

            fill: None,

5343

88

            stroke: None,

5344

88

            stroke_width: None,

5345

88

5346

88

5347

5348

5349

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

5350

88

fn render_svg_group(

5351

88

    node: &azul_core::xml::XmlNode,

5352

88

    pixmap: &mut AzulPixmap,

5353

88

    parent_transform: &TransAffine,

5354

88

) {

5355

88

    render_svg_group_with_style(

5356

88

        node,

5357

88

        pixmap,

5358

88

        parent_transform,

5359

88

        &SvgInheritedStyle::default(),

5360

);

5361

88

5362

5363

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

5364

11220

fn render_svg_group_with_style(

5365

11220

    node: &azul_core::xml::XmlNode,

5366

11220

    pixmap: &mut AzulPixmap,

5367

11220

    parent_transform: &TransAffine,

5368

11220

    parent_style: &SvgInheritedStyle,

5369

11220

) {

5370

    use agg_rust::math_stroke::{LineCap, LineJoin};

5371

    use azul_core::xml::{XmlNode, XmlNodeChild};

5372

5373

11220

    let group_transform = if let Some(t) = node.attributes.get_key("transform") {

5374

88

        let mut tf = parse_svg_transform(t.as_str());

5375

88

        tf.premultiply(parent_transform);

5376

88

tf

5377

    } else {

5378

11132

        parent_transform.clone()

5379

};

5380

5381

    // Inherit style from this group's attributes

5382

11220

    let group_style = SvgInheritedStyle {

5383

11220

        fill: node

5384

11220

            .attributes

5385

11220

            .get_key("fill")

5386

11220

            .map(|s| s.as_str().to_string())

5387

11220

            .or_else(|| parent_style.fill.clone()),

5388

11220

        stroke: node

5389

11220

            .attributes

5390

11220

            .get_key("stroke")

5391

11220

            .map(|s| s.as_str().to_string())

5392

11220

            .or_else(|| parent_style.stroke.clone()),

5393

11220

        stroke_width: node

5394

11220

            .attributes

5395

11220

            .get_key("stroke-width")

5396

11220

            .and_then(|s| s.as_str().parse().ok())

5397

11220

            .or(parent_style.stroke_width),

5398

};

5399

5400

54604

    for child in node.children.as_ref().iter() {

5401

54604

        let child_node = match child {

5402

21868

            XmlNodeChild::Element(e) => e,

5403

32736

            _ => continue,

5404

};

5405

5406

21868

        let tag = child_node.node_type.as_str().to_lowercase();

5407

5408

21868

        match tag.as_str() {

5409

21868

            "g" | "svg" => {

5410

10648

                render_svg_group_with_style(child_node, pixmap, &group_transform, &group_style);

5411

10648

5412

11220

            "path" | "circle" | "rect" | "ellipse" | "line" | "polygon" | "polyline" => {

5413

10736

                let path_storage = match build_agg_path(child_node) {

5414

10736

                    Some(p) => p,

5415

                    None => continue,

5416

};

5417

5418

                // Flatten bezier curves into line segments for the rasterizer

5419

10736

                let mut curved = agg_rust::conv_curve::ConvCurve::new(path_storage);

5420

5421

                // Per-element transform

5422

10736

                let elem_transform = if let Some(t) = child_node.attributes.get_key("transform") {

5423

                    let mut tf = parse_svg_transform(t.as_str());

5424

                    tf.premultiply(&group_transform);

5425

tf

5426

                } else {

5427

10736

                    group_transform.clone()

5428

};

5429

5430

                // Fill: element overrides group

5431

10736

                let fill_attr = child_node

5432

10736

                    .attributes

5433

10736

                    .get_key("fill")

5434

10736

                    .map(|s| s.as_str().to_string())

5435

10736

                    .or_else(|| group_style.fill.clone());

5436

10736

                let fill_color = match fill_attr.as_deref() {

5437

10560

                    Some("none") => None,

5438

9988

                    Some(c) => parse_svg_color(c),

5439

176

                    None => Some(Rgba8 {

5440

176

                        r: 0,

5441

176

                        g: 0,

5442

176

                        b: 0,

5443

176

                        a: 255,

5444

176

                    }), // SVG default

5445

};

5446

5447

10736

                let fill_opacity = child_node

5448

10736

                    .attributes

5449

10736

                    .get_key("fill-opacity")

5450

10736

                    .and_then(|s| s.as_str().parse::<f64>().ok())

5451

10736

                    .unwrap_or(1.0);

5452

5453

10736

                let opacity = child_node

5454

10736

                    .attributes

5455

10736

                    .get_key("opacity")

5456

10736

                    .and_then(|s| s.as_str().parse::<f64>().ok())

5457

10736

                    .unwrap_or(1.0);

5458

5459

10736

                if let Some(mut color) = fill_color {

5460

10164

                    color.a = ((color.a as f64) * fill_opacity * opacity).min(255.0) as u8;

5461

5462

10164

                    let fill_rule_str = child_node

5463

10164

                        .attributes

5464

10164

                        .get_key("fill-rule")

5465

10164

                        .map(|s| s.as_str().to_string());

5466

10164

                    let rule = match fill_rule_str.as_deref() {

5467

                        Some("evenodd") => FillingRule::EvenOdd,

5468

10164

                        _ => FillingRule::NonZero,

5469

};

5470

5471

10164

                    let mut transformed = ConvTransform::new(&mut curved, elem_transform.clone());

5472

10164

                    agg_fill_path(pixmap, &mut transformed, &color, rule);

5473

572

5474

5475

                // Stroke: element overrides group

5476

10736

                let stroke_attr = child_node

5477

10736

                    .attributes

5478

10736

                    .get_key("stroke")

5479

10736

                    .map(|s| s.as_str().to_string())

5480

10736

                    .or_else(|| group_style.stroke.clone());

5481

10736

                let stroke_color = match stroke_attr.as_deref() {

5482

7304

                    Some("none") | None => None,

5483

3432

                    Some(c) => parse_svg_color(c),

5484

};

5485

5486

10736

                if let Some(mut color) = stroke_color {

5487

3432

                    let stroke_opacity = child_node

5488

3432

                        .attributes

5489

3432

                        .get_key("stroke-opacity")

5490

3432

                        .and_then(|s| s.as_str().parse::<f64>().ok())

5491

3432

                        .unwrap_or(1.0);

5492

3432

                    color.a = ((color.a as f64) * stroke_opacity * opacity).min(255.0) as u8;

5493

5494

3432

                    let stroke_width = child_node

5495

3432

                        .attributes

5496

3432

                        .get_key("stroke-width")

5497

3432

                        .and_then(|s| s.as_str().parse::<f64>().ok())

5498

3432

                        .or(group_style.stroke_width)

5499

3432

                        .unwrap_or(1.0);

5500

5501

3432

                    let mut conv_stroke = ConvStroke::new(&mut curved);

5502

3432

                    conv_stroke.set_width(stroke_width);

5503

3432

                    conv_stroke.set_line_cap(LineCap::Round);

5504

3432

                    conv_stroke.set_line_join(LineJoin::Round);

5505

5506

3432

                    let mut transformed =

5507

3432

                        ConvTransform::new(&mut conv_stroke, elem_transform.clone());

5508

3432

                    agg_fill_path(pixmap, &mut transformed, &color, FillingRule::NonZero);

5509

7304

5510

5511

484

            _ => {

5512

484

                // Recurse into unknown containers (defs, symbol, etc.)

5513

484

                render_svg_group_with_style(child_node, pixmap, &group_transform, &group_style);

5514

484

5515

5516

5517

11220

5518

5519

/// Build an agg PathStorage from an SVG shape element's attributes.

5520

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

5521

10736

fn build_agg_path(node: &azul_core::xml::XmlNode) -> Option<PathStorage> {

5522

10736

    let tag = node.node_type.as_str().to_lowercase();

5523

10736

    match tag.as_str() {

5524

10736

        "path" => {

5525

10648

            let d = node.attributes.get_key("d")?;

5526

10648

            let mp = azul_core::path_parser::parse_svg_path_d(d.as_str()).ok()?;

5527

10648

            Some(svg_multi_polygon_to_path_storage(&mp))

5528

5529

88

        "circle" => {

5530

44

            let cx = attr_f64(node, "cx");

5531

44

            let cy = attr_f64(node, "cy");

5532

44

            let r = attr_f64(node, "r");

5533

44

            if r <= 0.0 {

5534

                return None;

5535

44

5536

44

            let mp = azul_core::path_parser::svg_circle_to_paths(cx as f32, cy as f32, r as f32);

5537

44

            let multi = azul_core::svg::SvgMultiPolygon {

5538

44

                rings: azul_core::svg::SvgPathVec::from_vec(vec![mp]),

5539

44

};

5540

44

            Some(svg_multi_polygon_to_path_storage(&multi))

5541

5542

44

        "rect" => {

5543

44

            let x = attr_f64(node, "x");

5544

44

            let y = attr_f64(node, "y");

5545

44

            let w = attr_f64(node, "width");

5546

44

            let h = attr_f64(node, "height");

5547

44

            let rx = attr_f64(node, "rx");

5548

44

            let ry = if let Some(v) = node.attributes.get_key("ry") {

5549

44

                v.as_str().parse().unwrap_or(rx)

5550

            } else {

5551

rx

5552

};

5553

44

            if w <= 0.0 || h <= 0.0 {

5554

                return None;

5555

44

5556

44

            let mp = azul_core::path_parser::svg_rect_to_path(

5557

44

                x as f32, y as f32, w as f32, h as f32, rx as f32, ry as f32,

5558

);

5559

44

            let multi = azul_core::svg::SvgMultiPolygon {

5560

44

                rings: azul_core::svg::SvgPathVec::from_vec(vec![mp]),

5561

44

};

5562

44

            Some(svg_multi_polygon_to_path_storage(&multi))

5563

5564

        "ellipse" => {

5565

            let cx = attr_f64(node, "cx");

5566

            let cy = attr_f64(node, "cy");

5567

            let rx = attr_f64(node, "rx");

5568

            let ry = attr_f64(node, "ry");

5569

            if rx <= 0.0 || ry <= 0.0 {

5570

                return None;

5571

5572

            // Use circle path with scaling

5573

            let mp = azul_core::path_parser::svg_circle_to_paths(cx as f32, cy as f32, 1.0);

5574

            let multi = azul_core::svg::SvgMultiPolygon {

5575

                rings: azul_core::svg::SvgPathVec::from_vec(vec![mp]),

5576

};

5577

            let mut ps = svg_multi_polygon_to_path_storage(&multi);

5578

            // Scale ellipse: we'll just build it directly instead

5579

            let mut path = PathStorage::new();

5580

            const KAPPA: f64 = 0.5522847498;

5581

            let kx = rx * KAPPA;

5582

            let ky = ry * KAPPA;

5583

            path.move_to(cx, cy - ry);

5584

            path.curve4(cx + kx, cy - ry, cx + rx, cy - ky, cx + rx, cy);

5585

            path.curve4(cx + rx, cy + ky, cx + kx, cy + ry, cx, cy + ry);

5586

            path.curve4(cx - kx, cy + ry, cx - rx, cy + ky, cx - rx, cy);

5587

            path.curve4(cx - rx, cy - ky, cx - kx, cy - ry, cx, cy - ry);

5588

            path.close_polygon(PATH_FLAGS_NONE);

5589

            Some(path)

5590

5591

        "line" => {

5592

            let x1 = attr_f64(node, "x1");

5593

            let y1 = attr_f64(node, "y1");

5594

            let x2 = attr_f64(node, "x2");

5595

            let y2 = attr_f64(node, "y2");

5596

            let mut path = PathStorage::new();

5597

            path.move_to(x1, y1);

5598

            path.line_to(x2, y2);

5599

            Some(path)

5600

5601

        "polygon" | "polyline" => {

5602

            let pts_str = node.attributes.get_key("points")?;

5603

            let nums: Vec<f64> = pts_str

5604

                .as_str()

5605

                .split(|c: char| c == ',' || c.is_ascii_whitespace())

5606

                .filter(|s| !s.is_empty())

5607

                .filter_map(|s| s.parse().ok())

5608

                .collect();

5609

            if nums.len() < 4 {

5610

                return None;

5611

5612

            let mut path = PathStorage::new();

5613

            path.move_to(nums[0], nums[1]);

5614

            for chunk in nums[2..].chunks_exact(2) {

5615

                path.line_to(chunk[0], chunk[1]);

5616

5617

            if tag == "polygon" {

5618

                path.close_polygon(PATH_FLAGS_NONE);

5619

5620

            Some(path)

5621

5622

        _ => None,

5623

5624

10736

5625

5626

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

5627

352

fn attr_f64(node: &azul_core::xml::XmlNode, key: &str) -> f64 {

5628

352

    node.attributes

5629

352

        .get_key(key)

5630

352

        .and_then(|s| s.as_str().parse().ok())

5631

352

        .unwrap_or(0.0)

5632

352

5633

5634

/// Convert SvgMultiPolygon to agg PathStorage.

5635

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

5636

10736

fn svg_multi_polygon_to_path_storage(mp: &azul_core::svg::SvgMultiPolygon) -> PathStorage {

5637

10736

    let mut path = PathStorage::new();

5638

10736

    for ring in mp.rings.as_ref().iter() {

5639

10692

        let mut first = true;

5640

92532

        for item in ring.items.as_ref().iter() {

5641

92532

            match item {

5642

9328

                azul_core::svg::SvgPathElement::Line(l) => {

5643

9328

                    if first {

5644

528

                        path.move_to(l.start.x as f64, l.start.y as f64);

5645

528

                        first = false;

5646

8800

5647

9328

                    path.line_to(l.end.x as f64, l.end.y as f64);

5648

5649

                azul_core::svg::SvgPathElement::QuadraticCurve(q) => {

5650

                    if first {

5651

                        path.move_to(q.start.x as f64, q.start.y as f64);

5652

                        first = false;

5653

5654

                    path.curve3(

5655

                        q.ctrl.x as f64,

5656

                        q.ctrl.y as f64,

5657

                        q.end.x as f64,

5658

                        q.end.y as f64,

5659

);

5660

5661

83204

                azul_core::svg::SvgPathElement::CubicCurve(c) => {

5662

83204

                    if first {

5663

10164

                        path.move_to(c.start.x as f64, c.start.y as f64);

5664

10164

                        first = false;

5665

73040

5666

83204

                    path.curve4(

5667

83204

                        c.ctrl_1.x as f64,

5668

83204

                        c.ctrl_1.y as f64,

5669

83204

                        c.ctrl_2.x as f64,

5670

83204

                        c.ctrl_2.y as f64,

5671

83204

                        c.end.x as f64,

5672

83204

                        c.end.y as f64,

5673

);

5674

5675

5676

5677

10692

        path.close_polygon(PATH_FLAGS_NONE);

5678

5679

10736

    path

5680

10736

5681

5682

/// Parse SVG transform attribute (supports matrix, translate, scale, rotate).

5683

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

5684

88

fn parse_svg_transform(s: &str) -> TransAffine {

5685

88

    let s = s.trim();

5686

5687

88

    let parse_nums = |inner: &str| -> Vec<f64> {

5688

88

        inner

5689

2816

            .split(|c: char| c == ',' || c.is_ascii_whitespace())

5690

352

            .filter(|s| !s.is_empty())

5691

352

            .filter_map(|s| s.parse().ok())

5692

88

            .collect()

5693

88

};

5694

5695

88

    if let Some(inner) = s.strip_prefix("matrix(").and_then(|s| s.strip_suffix(')')) {

5696

44

        let nums = parse_nums(inner);

5697

44

        if nums.len() == 6 {

5698

44

            return TransAffine::new_custom(nums[0], nums[1], nums[2], nums[3], nums[4], nums[5]);

5699

5700

44

    } else if let Some(inner) = s

5701

44

        .strip_prefix("translate(")

5702

44

        .and_then(|s| s.strip_suffix(')'))

5703

5704

44

        let nums = parse_nums(inner);

5705

44

        let tx = nums.first().copied().unwrap_or(0.0);

5706

44

        let ty = nums.get(1).copied().unwrap_or(0.0);

5707

44

        return TransAffine::new_custom(1.0, 0.0, 0.0, 1.0, tx, ty);

5708

    } else if let Some(inner) = s.strip_prefix("scale(").and_then(|s| s.strip_suffix(')')) {

5709

        let nums = parse_nums(inner);

5710

        let sx = nums.first().copied().unwrap_or(1.0);

5711

        let sy = nums.get(1).copied().unwrap_or(sx);

5712

        return TransAffine::new_custom(sx, 0.0, 0.0, sy, 0.0, 0.0);

5713

    } else if let Some(inner) = s.strip_prefix("rotate(").and_then(|s| s.strip_suffix(')')) {

5714

        let nums = parse_nums(inner);

5715

        let angle = nums.first().copied().unwrap_or(0.0).to_radians();

5716

        let cos_a = angle.cos();

5717

        let sin_a = angle.sin();

5718

        return TransAffine::new_custom(cos_a, sin_a, -sin_a, cos_a, 0.0, 0.0);

5719

5720

    TransAffine::new()

5721

88

5722

5723

/// Parse SVG color string (#RRGGBB, #RGB, named colors).

5724

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

5725

13420

fn parse_svg_color(s: &str) -> Option<Rgba8> {

5726

13420

    let s = s.trim();

5727

13420

    if s.starts_with('#') {

5728

13420

        let hex = &s[1..];

5729

13420

        return match hex.len() {

5730

            6 => {

5731

2552

                let r = u8::from_str_radix(&hex[0..2], 16).ok()?;

5732

2552

                let g = u8::from_str_radix(&hex[2..4], 16).ok()?;

5733

2552

                let b = u8::from_str_radix(&hex[4..6], 16).ok()?;

5734

2552

                Some(Rgba8 { r, g, b, a: 255 })

5735

5736

            3 => {

5737

10868

                let r = u8::from_str_radix(&hex[0..1], 16).ok()? * 17;

5738

10868

                let g = u8::from_str_radix(&hex[1..2], 16).ok()? * 17;

5739

10868

                let b = u8::from_str_radix(&hex[2..3], 16).ok()? * 17;

5740

10868

                Some(Rgba8 { r, g, b, a: 255 })

5741

5742

            _ => None,

5743

};

5744

5745

    match s.to_lowercase().as_str() {

5746

        "black" => Some(Rgba8 {

5747

            r: 0,

5748

            g: 0,

5749

            b: 0,

5750

            a: 255,

5751

}),

5752

        "white" => Some(Rgba8 {

5753

            r: 255,

5754

            g: 255,

5755

            b: 255,

5756

            a: 255,

5757

}),

5758

        "red" => Some(Rgba8 {

5759

            r: 255,

5760

            g: 0,

5761

            b: 0,

5762

            a: 255,

5763

}),

5764

        "green" => Some(Rgba8 {

5765

            r: 0,

5766

            g: 128,

5767

            b: 0,

5768

            a: 255,

5769

}),

5770

        "blue" => Some(Rgba8 {

5771

            r: 0,

5772

            g: 0,

5773

            b: 255,

5774

            a: 255,

5775

}),

5776

        "yellow" => Some(Rgba8 {

5777

            r: 255,

5778

            g: 255,

5779

            b: 0,

5780

            a: 255,

5781

}),

5782

        "orange" => Some(Rgba8 {

5783

            r: 255,

5784

            g: 165,

5785

            b: 0,

5786

            a: 255,

5787

}),

5788

        "gold" => Some(Rgba8 {

5789

            r: 255,

5790

            g: 215,

5791

            b: 0,

5792

            a: 255,

5793

}),

5794

        _ => None,

5795

5796

13420

5797

5798

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

5799

// scroll_shift_region — unit tests (#14 single-axis, #16 diagonal pan)

5800

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

5801

#[cfg(test)]

5802

mod scroll_shift_tests {

5803

    use super::*;

5804

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

5805

5806

    /// Pixmap where every pixel encodes its own coords: R = x&0xFF, G = y&0xFF.

5807

    /// After a shift, a pixel's (R,G) tells you which source pixel landed there,

5808

    /// so we can assert the move is an exact translation.

5809

5

    fn xy_pixmap(w: u32, h: u32) -> AzulPixmap {

5810

5

        let mut p = AzulPixmap::new(w, h).unwrap();

5811

5

        let d = p.data_mut();

5812

428

        for y in 0..h {

5813

68192

            for x in 0..w {

5814

68192

                let i = ((y * w + x) * 4) as usize;

5815

68192

                d[i] = (x & 0xFF) as u8;

5816

68192

                d[i + 1] = (y & 0xFF) as u8;

5817

68192

                d[i + 2] = 0;

5818

68192

                d[i + 3] = 255;

5819

68192

5820

5821

5

5822

5

5823

10

    fn at(p: &AzulPixmap, x: u32, y: u32) -> [u8; 4] {

5824

10

        let w = p.width();

5825

10

        let d = p.data();

5826

10

        let i = ((y * w + x) * 4) as usize;

5827

10

        [d[i], d[i + 1], d[i + 2], d[i + 3]]

5828

10

5829

31

    fn rect(x: f32, y: f32, w: f32, h: f32) -> LogicalRect {

5830

31

        LogicalRect {

5831

31

            origin: LogicalPosition::new(x, y),

5832

31

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

5833

31

5834

31

5835

5836

    #[test]

5837

1

    fn noop_when_delta_zero() {

5838

1

        let mut p = xy_pixmap(64, 64);

5839

1

        let strips = scroll_shift_region(&mut p, &rect(0.0, 0.0, 64.0, 64.0), (0.0, 0.0), 1.0);

5840

1

        assert!(strips.is_empty(), "zero delta must not shift or expose anything");

5841

        // Buffer untouched.

5842

1

        assert_eq!(at(&p, 10, 20), [10, 20, 0, 255]);

5843

1

5844

5845

    #[test]

5846

1

    fn vertical_scroll_one_strip_and_translates() {

5847

1

        let mut p = xy_pixmap(200, 100);

5848

        // Scroll DOWN by 30 → content moves UP → bottom strip exposed.

5849

1

        let strips = scroll_shift_region(&mut p, &rect(0.0, 0.0, 200.0, 100.0), (0.0, 30.0), 1.0);

5850

1

        assert_eq!(strips.len(), 1, "single-axis scroll = one strip, got {:?}", strips);

5851

1

        let s = &strips[0];

5852

1

        assert!(

5853

1

            (s.origin.y - (100.0 - s.size.height)).abs() < 0.01 && s.size.width == 200.0,

5854

            "vertical scroll-down must expose a full-width BOTTOM strip, got {:?}",

5855

5856

);

5857

        // Kept region (top): (x, y) now holds original (x, y+30).

5858

1

        assert_eq!(at(&p, 50, 10), [50, 40, 0, 255], "content not translated up by 30");

5859

1

5860

5861

    #[test]

5862

1

    fn diagonal_pan_two_strips_and_translates() {

5863

1

        let mut p = xy_pixmap(200, 100);

5864

        // Diagonal scroll down-right by (20, 30): content moves up-left.

5865

1

        let strips =

5866

1

            scroll_shift_region(&mut p, &rect(0.0, 0.0, 200.0, 100.0), (20.0, 30.0), 1.0);

5867

1

        assert_eq!(

5868

1

            strips.len(),

5869

2,

5870

            "diagonal pan must expose TWO strips (L-shape), got {:?}",

5871

            strips

5872

);

5873

        // One full-width strip (the vertical move) + one full-height strip (horizontal).

5874

1

        let has_h_strip = strips.iter().any(|s| s.size.width == 200.0);

5875

2

        let has_v_strip = strips.iter().any(|s| s.size.height == 100.0);

5876

1

        assert!(

5877

1

            has_h_strip && has_v_strip,

5878

            "expected a full-width AND a full-height strip, got {:?}",

5879

            strips

5880

);

5881

        // Kept top-left region: (sx,sy) now holds original (sx+20, sy+30).

5882

        // (50,40) is inside the kept block (bottom strip y>=69, right strip x>=179).

5883

1

        let got = at(&p, 50, 40);

5884

1

        assert_eq!(got[0], 70, "x not translated left by 20 (R channel)");

5885

1

        assert_eq!(got[1], 70, "y not translated up by 30 (G channel)");

5886

1

5887

5888

    #[test]

5889

1

    fn shift_only_touches_inside_clip() {

5890

1

        let mut p = xy_pixmap(200, 100);

5891

        // Clip is a sub-region; everything OUTSIDE must be byte-identical after.

5892

1

        let clip = rect(8.0, 16.0, 180.0, 60.0); // phys [8,188) x [16,76)

5893

1

        let _ = scroll_shift_region(&mut p, &clip, (0.0, 10.0), 1.0);

5894

7

        for &(x, y) in &[(0u32, 0u32), (199, 99), (100, 5), (100, 90), (2, 50), (190, 50)] {

5895

6

            assert_eq!(

5896

6

                at(&p, x, y),

5897

6

                [(x & 0xFF) as u8, (y & 0xFF) as u8, 0, 255],

5898

                "pixel ({},{}) OUTSIDE the clip was modified — scroll leaked past its frame",

5899

x,

5900

5901

);

5902

5903

        // Inside the kept region it DID move: (50,40) holds original (50,50).

5904

1

        assert_eq!(at(&p, 50, 40), [50, 50, 0, 255], "inside-clip content not shifted");

5905

1

5906

5907

    #[test]

5908

1

    fn shift_larger_than_region_returns_full_clip() {

5909

1

        let mut p = xy_pixmap(64, 64);

5910

1

        let clip = rect(0.0, 0.0, 64.0, 64.0);

5911

        // Shift exceeds the region height → whole clip exposed (no partial strip).

5912

1

        let strips = scroll_shift_region(&mut p, &clip, (0.0, 100.0), 1.0);

5913

1

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

5914

1

        assert_eq!(strips[0].size.width, 64.0);

5915

1

        assert_eq!(strips[0].size.height, 64.0);

5916

1

5917

5918

    // --- #20 fast-path eligibility ---

5919

    use crate::solver3::display_list::{

5920

        BorderRadius, DisplayList, DisplayListItem, WindowLogicalRect,

5921

};

5922

    use azul_css::props::basic::color::ColorU;

5923

5924

5

    fn dl(items: Vec<DisplayListItem>) -> DisplayList {

5925

5

        DisplayList {

5926

5

            items,

5927

5

            node_mapping: Vec::new(),

5928

5

            forced_page_breaks: Vec::new(),

5929

5

            fixed_position_item_ranges: Vec::new(),

5930

5

5931

5

5932

15

    fn wr(x: f32, y: f32, w: f32, h: f32) -> WindowLogicalRect {

5933

15

        rect(x, y, w, h).into()

5934

15

5935

10

    fn fill(x: f32, y: f32, w: f32, h: f32, a: u8) -> DisplayListItem {

5936

10

        DisplayListItem::Rect {

5937

10

            bounds: wr(x, y, w, h),

5938

10

            color: ColorU { r: 10, g: 20, b: 30, a },

5939

10

            border_radius: BorderRadius::default(),

5940

10

5941

10

5942

5

    fn scroll_frame(id: u64) -> DisplayListItem {

5943

5

        DisplayListItem::PushScrollFrame {

5944

5

            clip_bounds: wr(0.0, 0.0, 100.0, 100.0),

5945

5

            content_size: LogicalSize::new(100.0, 1000.0),

5946

5

            scroll_id: id,

5947

5

5948

5

5949

5950

    #[test]

5951

1

    fn eligible_when_no_backdrop_even_if_transparent() {

5952

        // Transparent content, but nothing painted behind the frame → safe.

5953

1

        let list = dl(vec![

5954

1

            scroll_frame(7),

5955

1

            fill(0.0, 0.0, 100.0, 30.0, 0), // transparent row

5956

1

            DisplayListItem::PopScrollFrame,

5957

]);

5958

1

        assert!(scroll_fast_path_eligible(&list, 7, &rect(0.0, 0.0, 100.0, 100.0), (0.0, 0.0)));

5959

1

5960

5961

    #[test]

5962

1

    fn eligible_when_backdrop_is_single_uniform_colour() {

5963

        // A SINGLE flat colour covering the whole clip behind transparent content

5964

        // drags invisibly (same colour everywhere) → aggressive policy keeps the

5965

        // fast path. (This is the common body/container background case.)

5966

1

        let list = dl(vec![

5967

1

            fill(0.0, 0.0, 100.0, 100.0, 255), // one flat colour covering the clip

5968

1

            scroll_frame(7),

5969

1

            fill(0.0, 0.0, 100.0, 30.0, 0), // transparent content

5970

1

            DisplayListItem::PopScrollFrame,

5971

]);

5972

1

        assert!(scroll_fast_path_eligible(&list, 7, &rect(0.0, 0.0, 100.0, 100.0), (0.0, 0.0)));

5973

1

5974

5975

    #[test]

5976

1

    fn ineligible_when_backdrop_is_non_uniform() {

5977

        // Two DIFFERENT colours behind transparent content → dragging them is

5978

        // visible → must full-repaint.

5979

1

        let mut left = fill(0.0, 0.0, 50.0, 100.0, 255);

5980

1

        if let DisplayListItem::Rect { color, .. } = &mut left {

5981

1

            *color = ColorU { r: 200, g: 0, b: 0, a: 255 };

5982

1

5983

1

        let mut right = fill(50.0, 0.0, 50.0, 100.0, 255);

5984

1

        if let DisplayListItem::Rect { color, .. } = &mut right {

5985

1

            *color = ColorU { r: 0, g: 0, b: 200, a: 255 };

5986

1

5987

1

        let list = dl(vec![

5988

1

            left,

5989

1

            right,

5990

1

            scroll_frame(7),

5991

1

            fill(0.0, 0.0, 100.0, 30.0, 0), // transparent content

5992

1

            DisplayListItem::PopScrollFrame,

5993

]);

5994

1

        assert!(!scroll_fast_path_eligible(&list, 7, &rect(0.0, 0.0, 100.0, 100.0), (0.0, 0.0)));

5995

1

5996

5997

    #[test]

5998

1

    fn ineligible_when_single_colour_only_partly_covers() {

5999

        // One flat colour that covers only PART of the clip (rest is clear): its

6000

        // edge against the clear would drag visibly → full-repaint.

6001

1

        let list = dl(vec![

6002

1

            fill(0.0, 0.0, 100.0, 40.0, 255), // covers only the top 40px

6003

1

            scroll_frame(7),

6004

1

            fill(0.0, 0.0, 100.0, 30.0, 0), // transparent content

6005

1

            DisplayListItem::PopScrollFrame,

6006

]);

6007

1

        assert!(!scroll_fast_path_eligible(&list, 7, &rect(0.0, 0.0, 100.0, 100.0), (0.0, 0.0)));

6008

1

6009

6010

    #[test]

6011

1

    fn eligible_when_backdrop_but_opaque_content_covers() {

6012

        // Backdrop behind, but the scrolling content opaquely covers the clip →

6013

        // nothing behind ever shows through → fast path is safe.

6014

1

        let list = dl(vec![

6015

1

            fill(0.0, 0.0, 100.0, 100.0, 255), // backdrop

6016

1

            scroll_frame(7),

6017

1

            fill(0.0, 0.0, 100.0, 1000.0, 255), // opaque full-content cover

6018

1

            DisplayListItem::PopScrollFrame,

6019

]);

6020

1

        assert!(scroll_fast_path_eligible(&list, 7, &rect(0.0, 0.0, 100.0, 100.0), (0.0, 0.0)));

6021

1

6022

6023

    #[test]

6024

1

    fn rect_covered_by_detects_gap() {

6025

1

        let target = rect(0.0, 0.0, 100.0, 100.0);

6026

        // Single full cover.

6027

1

        assert!(rect_covered_by(&target, &[rect(0.0, 0.0, 100.0, 100.0)]));

6028

        // Two halves tile it.

6029

1

        assert!(rect_covered_by(

6030

1

            &target,

6031

1

            &[rect(0.0, 0.0, 100.0, 50.0), rect(0.0, 50.0, 100.0, 50.0)]

6032

));

6033

        // A gap in the middle is NOT covered.

6034

1

        assert!(!rect_covered_by(

6035

1

            &target,

6036

1

            &[rect(0.0, 0.0, 100.0, 40.0), rect(0.0, 60.0, 100.0, 40.0)]

6037

1

));

6038

        // Empty → not covered.

6039

1

        assert!(!rect_covered_by(&target, &[]));

6040

1

6041