Grcov report - taffy

1

//! Bridge between Azul's CSS style system and the Taffy layout engine.

2

//!

3

//! This module translates Azul CSS properties into Taffy's `Style` struct and

4

//! implements Taffy's `TraversePartialTree`, `LayoutPartialTree`, `CacheTree`,

5

//! `LayoutFlexboxContainer`, and `LayoutGridContainer` traits via the

6

//! [`TaffyBridge`] struct. The main entry point is [`layout_taffy_subtree`],

7

//! which is called from `fc.rs` when a flex or grid formatting context is

8

//! encountered during layout.

9

10

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

11

use crate::solver3::calc::CalcResolveContext;

12

use crate::solver3::getters::{get_overflow_x, get_overflow_y};

13

use azul_core::dom::FormattingContext;

14

use azul_css::{

15

    css::CssPropertyValue,

16

    props::{

17

        basic::{

18

            pixel::{DEFAULT_FONT_SIZE, PT_TO_PX},

19

            PixelValue, SizeMetric,

20

},

21

        layout::{

22

            dimensions::CalcAstItemVec,

23

            flex::LayoutFlexBasis,

24

            grid::{GridAutoTracks, GridTemplate, GridTrackSizing},

25

            LayoutAlignContent, LayoutAlignItems, LayoutAlignSelf, LayoutDisplay,

26

            LayoutFlexDirection, LayoutFlexWrap, LayoutGridAutoFlow, LayoutJustifyContent,

27

            LayoutPosition, LayoutWritingMode,

28

},

29

        property::{

30

            LayoutAlignContentValue, LayoutAlignItemsValue, LayoutAlignSelfValue,

31

            LayoutDisplayValue, LayoutFlexDirectionValue, LayoutFlexWrapValue,

32

            LayoutGridAutoColumnsValue, LayoutGridAutoFlowValue, LayoutGridAutoRowsValue,

33

            LayoutGridTemplateColumnsValue, LayoutGridTemplateRowsValue, LayoutJustifyContentValue,

34

            LayoutPositionValue,

35

},

36

},

37

};

38

use taffy::style::{MaxTrackSizingFunction, MinTrackSizingFunction, TrackSizingFunction};

39

40

/// CSS reference pixels per inch (96 dpi per CSS Values spec).

41

const CSS_PX_PER_INCH: f32 = 96.0;

42

43

/// Convert `PixelValue` to pixels, only for absolute units (no %, and em/rem use fallback)

44

/// Used where proper resolution context is not available (grid tracks, etc.)

45

#[allow(clippy::match_same_arms)] // enum/value mapping/dispatch table: one arm per input variant (or cross-type bindings that can't merge)

46

1418815

fn pixel_value_to_pixels_fallback(pv: &PixelValue) -> Option<f32> {

47

1418815

    match pv.metric {

48

1362107

        SizeMetric::Px => Some(pv.number.get()),

49

10

        SizeMetric::Pt => Some(pv.number.get() * PT_TO_PX),

50

7

        SizeMetric::In => Some(pv.number.get() * CSS_PX_PER_INCH),

51

7

        SizeMetric::Cm => Some(pv.number.get() * CSS_PX_PER_INCH / 2.54),

52

7

        SizeMetric::Mm => Some(pv.number.get() * CSS_PX_PER_INCH / 25.4),

53

        // For em/rem, use DEFAULT_FONT_SIZE as fallback (not ideal but needed without context)

54

55905

        SizeMetric::Em | SizeMetric::Rem => Some(pv.number.get() * DEFAULT_FONT_SIZE),

55

745

        SizeMetric::Percent => None, // Cannot resolve without containing block

56

        // Viewport units: Cannot resolve without viewport context

57

27

        SizeMetric::Vw | SizeMetric::Vh | SizeMetric::Vmin | SizeMetric::Vmax => None,

58

59

1418815

60

61

/// Converts an Azul `grid-template-rows` value into Taffy grid template components.

62

35

fn grid_template_rows_to_taffy(

63

35

    val: LayoutGridTemplateRowsValue,

64

35

) -> Vec<GridTemplateComponent<String>> {

65

35

    let auto_tracks = val.get_property_or_default().unwrap_or_default();

66

35

    auto_tracks

67

35

        .tracks

68

35

        .iter()

69

53

        .map(|track| GridTemplateComponent::Single(translate_track(track)))

70

35

        .collect()

71

35

72

73

/// Converts an Azul `grid-template-columns` value into Taffy grid template components.

74

35

fn grid_template_columns_to_taffy(

75

35

    val: LayoutGridTemplateColumnsValue,

76

35

) -> Vec<GridTemplateComponent<String>> {

77

35

    let auto_tracks = val.get_property_or_default().unwrap_or_default();

78

35

    auto_tracks

79

35

        .tracks

80

35

        .iter()

81

2132

        .map(|track| GridTemplateComponent::Single(translate_track(track)))

82

35

        .collect()

83

35

84

85

/// Converts an Azul `grid-auto-rows` value into Taffy min/max track sizing pairs.

86

7

fn grid_auto_rows_to_taffy(

87

7

    val: LayoutGridAutoRowsValue,

88

7

) -> Vec<taffy::MinMax<MinTrackSizingFunction, MaxTrackSizingFunction>> {

89

7

    let auto_tracks = val.get_property_or_default().unwrap_or_default();

90

7

    let tracks = auto_tracks.tracks;

91

7

    tracks

92

7

        .iter()

93

7

        .map(|track| taffy::MinMax {

94

4

            min: translate_track(track).min,

95

4

            max: translate_track(track).max,

96

4

})

97

7

        .collect()

98

7

99

100

/// Converts an Azul `grid-auto-columns` value into Taffy track sizing functions.

101

7

fn grid_auto_columns_to_taffy(

102

7

    val: LayoutGridAutoColumnsValue,

103

7

) -> Vec<taffy::TrackSizingFunction> {

104

7

    let auto_tracks = val.get_property_or_default().unwrap_or_default();

105

7

    auto_tracks.tracks.iter().map(translate_track).collect()

106

7

107

108

#[allow(clippy::cast_precision_loss)] // bounded layout/render numeric cast

109

4554

fn translate_track(track: &GridTrackSizing) -> taffy::TrackSizingFunction {

110

    // Helper to resolve PixelValue to absolute pixels (handles em, rem, but not %)

111

    // Grid track sizing in Taffy doesn't support % - only absolute values

112

4554

    let px_to_float = |pv: PixelValue| -> f32 {

113

1157

        pixel_value_to_pixels_fallback(&pv).unwrap_or(0.0)

114

1157

};

115

116

4554

    match track {

117

6

        GridTrackSizing::MinContent => minmax(

118

6

            MinTrackSizingFunction::min_content(),

119

6

            MaxTrackSizingFunction::min_content(),

120

),

121

70

        GridTrackSizing::MaxContent => minmax(

122

70

            MinTrackSizingFunction::max_content(),

123

70

            MaxTrackSizingFunction::max_content(),

124

),

125

1165

        GridTrackSizing::MinMax(minmax_box) => minmax(

126

1165

            translate_track(&minmax_box.min).min,

127

1165

            translate_track(&minmax_box.max).max,

128

),

129

1147

        GridTrackSizing::Fixed(px) => {

130

            // Fixed tracks: resolve em/rem to pixels

131

            // Note: % is not supported in grid track sizing (CSS Grid spec)

132

1147

            let pixels = px_to_float(*px);

133

1147

            minmax(

134

1147

                MinTrackSizingFunction::length(pixels),

135

1147

                MaxTrackSizingFunction::length(pixels),

136

137

138

2153

        GridTrackSizing::Fr(fr) => {

139

            // Fr units: minmax(auto, Xfr) per CSS Grid spec

140

            // The min is auto, max is the fractional value

141

            // fr is stored as i32 * 100 (e.g., 1fr = 100, 2fr = 200)

142

2153

            minmax(

143

2153

                MinTrackSizingFunction::auto(),

144

2153

                MaxTrackSizingFunction::fr(*fr as f32 / 100.0),

145

146

147

3

        GridTrackSizing::Auto => minmax(

148

3

            MinTrackSizingFunction::min_content(),

149

3

            MaxTrackSizingFunction::max_content(),

150

),

151

10

        GridTrackSizing::FitContent(px) => {

152

            // fit-content: resolve em/rem to pixels

153

10

            let pixels = px_to_float(*px);

154

10

            minmax(

155

10

                MinTrackSizingFunction::length(pixels),

156

10

                MaxTrackSizingFunction::max_content(),

157

158

159

160

4554

161

162

4582

const fn minmax(min: MinTrackSizingFunction, max: MaxTrackSizingFunction) -> taffy::TrackSizingFunction {

163

4582

    TrackSizingFunction { min, max }

164

4582

165

166

111693

fn layout_display_to_taffy(val: LayoutDisplayValue) -> Display {

167

111693

    match val.get_property_or_default().unwrap_or_default() {

168

2

        LayoutDisplay::None => Display::None,

169

57351

        LayoutDisplay::Flex | LayoutDisplay::InlineFlex => Display::Flex,

170

29

        LayoutDisplay::Grid | LayoutDisplay::InlineGrid => Display::Grid,

171

54311

        _ => Display::Block,

172

173

111693

174

175

// to determine their CB; Taffy's Position::Absolute handles this for both flex and grid

176

#[allow(clippy::match_same_arms)] // enum/value mapping/dispatch table: one arm per input variant (or cross-type bindings that can't merge)

177

7

fn layout_position_to_taffy(val: LayoutPositionValue) -> Position {

178

7

    match val.get_property_or_default().unwrap_or_default() {

179

1

        LayoutPosition::Absolute => Position::Absolute,

180

1

        LayoutPosition::Fixed => Position::Absolute, // Taffy has no Fixed variant

181

1

        LayoutPosition::Relative => Position::Relative,

182

3

        LayoutPosition::Static => Position::Relative,

183

1

        LayoutPosition::Sticky => Position::Relative, // Sticky treated as Relative

184

185

7

186

187

#[allow(clippy::cast_sign_loss)] // bounded layout/render numeric cast

188

10

fn decode_compact_grid_line(v: i16) -> GridPlacement<String> {

189

10

    if v == azul_css::compact_cache::I16_AUTO || v == azul_css::compact_cache::I16_SENTINEL {

190

3

        GridPlacement::Auto

191

7

    } else if v < 0 {

192

4

        GridPlacement::<String>::from_span((-v) as u16)

193

    } else {

194

3

        GridPlacement::<String>::from_line_index(v)

195

196

10

197

198

37

fn grid_auto_flow_to_taffy(val: LayoutGridAutoFlowValue) -> GridAutoFlow {

199

37

    match val.get_property_or_default().unwrap_or_default() {

200

34

        LayoutGridAutoFlow::Row => GridAutoFlow::Row,

201

1

        LayoutGridAutoFlow::Column => GridAutoFlow::Column,

202

1

        LayoutGridAutoFlow::RowDense => GridAutoFlow::RowDense,

203

1

        LayoutGridAutoFlow::ColumnDense => GridAutoFlow::ColumnDense,

204

205

37

206

207

/// Convert an azul `GridLine` (single start or end) to a Taffy `GridPlacement`.

208

#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)] // bounded layout/render numeric cast

209

202

fn grid_line_to_taffy(

210

202

    line: &azul_css::props::layout::grid::GridLine,

211

202

) -> GridPlacement<String> {

212

    use azul_css::props::layout::grid::GridLine as AzGridLine;

213

    use taffy::style_helpers::{TaffyGridLine, TaffyGridSpan};

214

202

    match line {

215

3

        AzGridLine::Auto => GridPlacement::Auto,

216

7

        AzGridLine::Line(n) => {

217

7

            GridPlacement::<String>::from_line_index(*n as i16)

218

219

6

        AzGridLine::Span(n) => GridPlacement::<String>::from_span(*n as u16),

220

186

        AzGridLine::Named(named) => {

221

            // Named lines: use the name with optional span

222

186

            let name = named.grid_line_name.as_str().to_string();

223

186

            if named.span_count > 0 {

224

3

                GridPlacement::NamedSpan(name, named.span_count as u16)

225

            } else {

226

183

                GridPlacement::NamedLine(name, 0)

227

228

229

230

202

231

232

/// Convert an azul `GridPlacement` (grid-column / grid-row) to a Taffy `Line<GridPlacement>`.

233

92

fn grid_placement_to_taffy(

234

92

    placement: &azul_css::props::layout::grid::GridPlacement,

235

92

) -> Line<GridPlacement<String>> {

236

92

    Line {

237

92

        start: grid_line_to_taffy(&placement.grid_start),

238

92

        end: grid_line_to_taffy(&placement.grid_end),

239

92

240

92

241

242

111677

fn layout_flex_direction_to_taffy(val: LayoutFlexDirectionValue) -> FlexDirection {

243

111677

    match val.get_property_or_default().unwrap_or_default() {

244

94146

        LayoutFlexDirection::Row => FlexDirection::Row,

245

1

        LayoutFlexDirection::RowReverse => FlexDirection::RowReverse,

246

17529

        LayoutFlexDirection::Column => FlexDirection::Column,

247

1

        LayoutFlexDirection::ColumnReverse => FlexDirection::ColumnReverse,

248

249

111677

250

251

111676

fn layout_flex_wrap_to_taffy(val: LayoutFlexWrapValue) -> FlexWrap {

252

111676

    match val.get_property_or_default().unwrap_or_default() {

253

111665

        LayoutFlexWrap::NoWrap => FlexWrap::NoWrap,

254

10

        LayoutFlexWrap::Wrap => FlexWrap::Wrap,

255

1

        LayoutFlexWrap::WrapReverse => FlexWrap::WrapReverse,

256

257

111676

258

259

111679

fn layout_align_items_to_taffy(val: LayoutAlignItemsValue) -> AlignItems {

260

111679

    match val.get_property_or_default().unwrap_or_default() {

261

68555

        LayoutAlignItems::Stretch => AlignItems::Stretch,

262

35020

        LayoutAlignItems::Center => AlignItems::Center,

263

8102

        LayoutAlignItems::Start => AlignItems::FlexStart,

264

1

        LayoutAlignItems::End => AlignItems::FlexEnd,

265

1

        LayoutAlignItems::Baseline => AlignItems::Baseline,

266

267

111679

268

269

8

fn layout_align_self_to_taffy(val: LayoutAlignSelfValue) -> Option<AlignSelf> {

270

8

    match val.get_property_or_default().unwrap_or_default() {

271

3

        LayoutAlignSelf::Auto => None, // Auto means inherit from parent's align-items (for non-abspos; abspos auto computes to itself per spec)

272

1

        LayoutAlignSelf::Start => Some(AlignSelf::FlexStart),

273

1

        LayoutAlignSelf::End => Some(AlignSelf::FlexEnd),

274

1

        LayoutAlignSelf::Center => Some(AlignSelf::Center),

275

1

        LayoutAlignSelf::Baseline => Some(AlignSelf::Baseline),

276

1

        LayoutAlignSelf::Stretch => Some(AlignSelf::Stretch),

277

278

8

279

280

111679

fn layout_align_content_to_taffy(val: LayoutAlignContentValue) -> AlignContent {

281

111679

    match val.get_property_or_default().unwrap_or_default() {

282

1

        LayoutAlignContent::Start => AlignContent::FlexStart,

283

1

        LayoutAlignContent::End => AlignContent::FlexEnd,

284

1

        LayoutAlignContent::Center => AlignContent::Center,

285

111674

        LayoutAlignContent::Stretch => AlignContent::Stretch,

286

1

        LayoutAlignContent::SpaceBetween => AlignContent::SpaceBetween,

287

1

        LayoutAlignContent::SpaceAround => AlignContent::SpaceAround,

288

289

111679

290

291

9

fn layout_justify_content_to_taffy(val: LayoutJustifyContentValue) -> JustifyContent {

292

9

    match val.get_property_or_default().unwrap_or_default() {

293

1

        LayoutJustifyContent::FlexStart => JustifyContent::FlexStart,

294

1

        LayoutJustifyContent::FlexEnd => JustifyContent::FlexEnd,

295

2

        LayoutJustifyContent::Start => JustifyContent::Start,

296

1

        LayoutJustifyContent::End => JustifyContent::End,

297

1

        LayoutJustifyContent::Center => JustifyContent::Center,

298

1

        LayoutJustifyContent::SpaceBetween => JustifyContent::SpaceBetween,

299

1

        LayoutJustifyContent::SpaceAround => JustifyContent::SpaceAround,

300

1

        LayoutJustifyContent::SpaceEvenly => JustifyContent::SpaceEvenly,

301

302

9

303

304

6

fn layout_justify_items_to_taffy(

305

6

    val: azul_css::props::property::LayoutJustifyItemsValue,

306

6

) -> AlignItems {

307

    use azul_css::props::layout::grid::LayoutJustifyItems;

308

6

    match val.get_property_or_default().unwrap_or_default() {

309

2

        LayoutJustifyItems::Start => AlignItems::Start,

310

1

        LayoutJustifyItems::End => AlignItems::End,

311

1

        LayoutJustifyItems::Center => AlignItems::Center,

312

2

        LayoutJustifyItems::Stretch => AlignItems::Stretch,

313

314

6

315

316

// TODO: visibility, z_index still missing

317

// --- CSS <-> Taffy conversion functions ---

318

319

use std::{collections::{BTreeMap, HashMap}, sync::Arc};

320

321

use azul_core::{dom::NodeId, geom::LogicalSize, styled_dom::StyledDom};

322

use azul_css::props::{

323

    layout::{LayoutHeight, LayoutWidth},

324

    property::{CssProperty, CssPropertyType},

325

};

326

use taffy::{

327

    compute_cached_layout, compute_flexbox_layout, compute_grid_layout, compute_leaf_layout,

328

    prelude::*, CacheTree, LayoutFlexboxContainer, LayoutGridContainer, LayoutInput, LayoutOutput,

329

    RunMode,

330

};

331

332

use crate::{

333

    font_traits::{FontLoaderTrait, ParsedFontTrait},

334

    solver3::{

335

        fc::{

336

            translate_taffy_point_back, translate_taffy_size_back, FloatingContext,

337

            LayoutConstraints, TextAlign as FcTextAlign,

338

},

339

        getters::{

340

            get_align_content, get_align_items, get_css_border_bottom_width,

341

            get_css_border_left_width, get_css_border_right_width,

342

            get_css_border_top_width, get_css_box_sizing, get_css_bottom, get_css_height, get_css_left,

343

            get_css_margin_bottom, get_css_margin_left, get_css_margin_right, get_css_margin_top,

344

            get_css_max_height, get_css_max_width, get_css_min_height, get_css_min_width,

345

            get_css_padding_bottom, get_css_padding_left, get_css_padding_right,

346

            get_css_padding_top, get_css_right, get_css_top, get_css_width, get_flex_direction,

347

            get_position, MultiValue,

348

},

349

        layout_tree::{get_display_type, LayoutTree},

350

        sizing, LayoutContext,

351

},

352

};

353

354

/// Coordinate space the `taffy_content_*` arguments of

355

/// [`compute_taffy_scrollbar_info`] are measured in.

356

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

357

enum ContentSizeOrigin {

358

    /// Taffy's `LayoutOutput::content_size`: child extents measured from the

359

    /// BORDER-BOX origin, so the leading border + padding ride along as an

360

    /// offset and the flex path adds the trailing padding on top.

361

    BorderBox,

362

    /// Our own BFC/IFC `overflow_size`, already relative to the content box.

363

    ContentBox,

364

365

366

/// Shared scrollbar detection for Taffy-managed flex/grid nodes.

367

///

368

/// When Taffy lays out a flex/grid container, it may expand the container

369

/// beyond the CSS-specified size (Taffy doesn't know about `overflow`).

370

/// This function resolves the CSS-constrained container size, computes

371

/// content vs. container overflow, and returns the resulting `ScrollbarRequirements`

372

/// plus the effective content size (for `overflow_content_size`).

373

///

374

/// Returns `(scrollbar_info, effective_content_width, effective_content_height)`.

375

318518

fn compute_taffy_scrollbar_info<T: ParsedFontTrait>(

376

318518

    ctx: &LayoutContext<'_, T>,

377

318518

    tree: &LayoutTree,

378

318518

    node_idx: usize,

379

318518

    result_width: f32,

380

318518

    result_height: f32,

381

318518

    taffy_content_width: f32,

382

318518

    taffy_content_height: f32,

383

318518

    content_origin: ContentSizeOrigin,

384

318518

) -> (crate::solver3::scrollbar::ScrollbarRequirements, f32, f32) {

385

    use crate::solver3::scrollbar::ScrollbarRequirements;

386

387

318518

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

388

318518

    let dom_id = node.and_then(|n| n.dom_node_id);

389

390

318518

    let Some(dom_id) = dom_id else {

391

3

        return (ScrollbarRequirements::default(), 0.0, 0.0);

392

};

393

394

318515

    let styled_node_state = ctx

395

318515

        .styled_dom

396

318515

        .styled_nodes

397

318515

        .as_container()

398

318515

        .get(dom_id)

399

318515

        .map(|s| s.styled_node_state)

400

318515

        .unwrap_or_default();

401

402

    // Compute padding + border from the node's box_props

403

318515

    let (padding_width, padding_height, border_width, border_height, border_left, border_top) = tree

404

318515

        .get(LayoutNodeId::new(node_idx))

405

318515

        .map_or((0.0, 0.0, 0.0, 0.0, 0.0, 0.0), |node| {

406

318515

            let bp = node.box_props.unpack();

407

318515

408

318515

                bp.padding.left + bp.padding.right,

409

318515

                bp.padding.top + bp.padding.bottom,

410

318515

                bp.border.left + bp.border.right,

411

318515

                bp.border.top + bp.border.bottom,

412

318515

                bp.border.left,

413

318515

                bp.border.top,

414

318515

415

318515

});

416

417

    // Use CSS-specified dimensions as the container constraint.

418

    // Taffy may have expanded the box beyond these, but the CSS spec says

419

    // the container clips at the specified size.

420

318515

    let css_height = get_css_height(ctx.styled_dom, dom_id, &styled_node_state);

421

318515

    let css_width = get_css_width(ctx.styled_dom, dom_id, &styled_node_state);

422

423

318515

    let result_content_w = result_width - padding_width - border_width;

424

318515

    let result_content_h = result_height - padding_height - border_height;

425

426

318515

    let css_container_w = css_width

427

318515

        .exact()

428

318515

        .and_then(|w| css_width_to_px(&w))

429

318515

        .unwrap_or(result_content_w)

430

318515

        .max(0.0);

431

432

318515

    let css_container_h = css_height

433

318515

        .exact()

434

318515

        .and_then(|h| css_height_to_px(&h))

435

318515

        .unwrap_or(result_content_h)

436

318515

        .max(0.0);

437

438

    // Content size: use the caller's content_size if non-zero,

439

    // else result size minus padding/border (Taffy expanded to fit).

440

//

441

    // IMPORTANT: Taffy's content_size is measured from (0,0) of the BORDER box.

442

    // Child positions therefore carry border.left/top AND the leading padding as

443

    // an offset, and the flex path adds the TRAILING padding on top

444

    // (`content_size.height += content_box_inset.bottom - border.bottom`).

445

    // container_size below is a content-box size, so the whole inset has to come

446

    // off to align the coordinate spaces: subtracting only the border left a

447

    // `padding-top: 18px` container reporting content = viewport + 18px, i.e. a

448

    // phantom `overflow: auto` scrollbar whose thumb spans ~98% of the track and

449

    // whose max_scroll is 18px. Subtracting the padding SUM (leading + trailing)

450

    // leaves the pure child extent, so a container whose children fit reports

451

    // content == container (no bar) and a genuinely overflowing one keeps

452

    // max_scroll = children − content box.

453

//

454

    // Our own BFC/IFC overflow_size is already content-box relative and must not

455

    // be adjusted at all — hence `content_origin`.

456

318515

    let (inset_w, inset_h) = match content_origin {

457

51727

        ContentSizeOrigin::BorderBox => (border_left + padding_width, border_top + padding_height),

458

266788

        ContentSizeOrigin::ContentBox => (0.0, 0.0),

459

};

460

318515

    let content_w = if taffy_content_width > 0.0 {

461

242834

        (taffy_content_width - inset_w).max(0.0)

462

    } else {

463

75681

        result_content_w.max(0.0)

464

};

465

318515

    let content_h = if taffy_content_height > 0.0 {

466

243108

        (taffy_content_height - inset_h).max(0.0)

467

    } else {

468

75407

        result_content_h.max(0.0)

469

};

470

471

318515

    let content_size = LogicalSize::new(content_w, content_h);

472

318515

    let container_size = LogicalSize::new(css_container_w, css_container_h);

473

474

318515

    let scrollbar_info =

475

318515

        crate::solver3::cache::compute_scrollbar_info_core(ctx, dom_id, &styled_node_state, content_size, container_size);

476

477

318515

    (scrollbar_info, content_w, content_h)

478

318518

479

480

/// Convert `LayoutWidth::Px(…)` to `f32`, returning None for non-px units.

481

7968

fn css_width_to_px(w: &LayoutWidth) -> Option<f32> {

482

7968

    match w {

483

7963

        LayoutWidth::Px(px) => pixel_value_to_pixels_fallback(px),

484

5

        _ => None,

485

486

7968

487

488

/// Convert `LayoutHeight::Px(…)` to `f32`, returning None for non-px units.

489

26811

fn css_height_to_px(h: &LayoutHeight) -> Option<f32> {

490

26811

    match h {

491

26806

        LayoutHeight::Px(px) => pixel_value_to_pixels_fallback(px),

492

5

        _ => None,

493

494

26811

495

496

// Helper function to convert MultiValue<PixelValue> to LengthPercentageAuto

497

446712

fn multi_value_to_lpa(mv: MultiValue<PixelValue>) -> LengthPercentageAuto {

498

446712

    match mv {

499

        MultiValue::Auto | MultiValue::Initial | MultiValue::Inherit => {

500

446668

            LengthPercentageAuto::auto()

501

502

44

        MultiValue::Exact(pv) => pixel_value_to_pixels_fallback(&pv)

503

44

            .map(LengthPercentageAuto::length)

504

44

            .or_else(|| {

505

5

                pv.to_percent()

506

5

                    .map(|p| LengthPercentageAuto::percent(p.get()))

507

5

})

508

44

            .unwrap_or_else(LengthPercentageAuto::auto),

509

510

446712

511

512

// Helper function to convert MultiValue<PixelValue> to LengthPercentageAuto for margins

513

// CSS spec: margin initial value is 0, but `auto` has special centering meaning in flexbox

514

446707

fn multi_value_to_lpa_margin(mv: MultiValue<PixelValue>) -> LengthPercentageAuto {

515

446707

    match mv {

516

        MultiValue::Auto => {

517

37

            LengthPercentageAuto::auto() // Preserve auto for flexbox centering

518

519

        MultiValue::Initial | MultiValue::Inherit => {

520

14

            LengthPercentageAuto::length(0.0) // Margins' initial value is 0

521

522

446656

        MultiValue::Exact(pv) => {

523

446656

            pixel_value_to_pixels_fallback(&pv)

524

446656

                .map(LengthPercentageAuto::length)

525

446656

                .or_else(|| {

526

2

                    pv.to_percent()

527

2

                        .map(|p| LengthPercentageAuto::percent(p.get()))

528

2

})

529

446656

                .unwrap_or_else(|| LengthPercentageAuto::length(0.0)) // Fallback to 0 for

530

                                                                             // margins

531

532

533

446707

534

535

// Helper function to convert MultiValue<PixelValue> to LengthPercentage

536

893420

fn multi_value_to_lp(mv: MultiValue<PixelValue>) -> LengthPercentage {

537

893420

    match mv {

538

        MultiValue::Auto | MultiValue::Initial | MultiValue::Inherit => {

539

27

            LengthPercentage::ZERO

540

541

893393

        MultiValue::Exact(pv) => pixel_value_to_pixels_fallback(&pv)

542

893393

            .map(LengthPercentage::length)

543

893393

            .or_else(|| {

544

8

                pv.to_percent()

545

8

                    .map(|p| LengthPercentage::percent(p.get()))

546

8

})

547

893393

            .unwrap_or(LengthPercentage::ZERO),

548

549

893420

550

551

// Helper function to convert plain PixelValue to LengthPercentage

552

/// Converts Azul's CSS overflow value to Taffy's Overflow enum.

553

///

554

/// Taffy only has Visible, Clip, Hidden, Scroll (no Auto).

555

/// CSS `auto` behaves like `scroll` from a layout perspective —

556

/// it constrains the container and enables scrolling.

557

#[allow(clippy::match_same_arms)] // enum/value mapping/dispatch table: one arm per input variant (or cross-type bindings that can't merge)

558

223358

const fn azul_overflow_to_taffy(ov: MultiValue<azul_css::props::layout::LayoutOverflow>) -> taffy::Overflow {

559

    use azul_css::props::layout::LayoutOverflow;

560

223349

    match ov {

561

217982

        MultiValue::Exact(LayoutOverflow::Visible) => taffy::Overflow::Visible,

562

5257

        MultiValue::Exact(LayoutOverflow::Hidden) => taffy::Overflow::Hidden,

563

90

        MultiValue::Exact(LayoutOverflow::Scroll) => taffy::Overflow::Scroll,

564

19

        MultiValue::Exact(LayoutOverflow::Auto) => taffy::Overflow::Scroll, // Auto acts like scroll for layout

565

1

        MultiValue::Exact(LayoutOverflow::Clip) => taffy::Overflow::Clip,

566

9

        _ => taffy::Overflow::Visible, // default

567

568

223358

569

570

5106

fn pixel_to_lp(pv: PixelValue) -> LengthPercentage {

571

5106

    pixel_value_to_pixels_fallback(&pv)

572

5106

        .map(LengthPercentage::length)

573

5106

        .or_else(|| {

574

4

            pv.to_percent()

575

4

                .map(|p| LengthPercentage::percent(p.get()))

576

4

})

577

5106

        .unwrap_or(LengthPercentage::ZERO)

578

5106

579

580

/// Slow path for flex-basis: full property cache lookup + decode.

581

/// Extracted to avoid duplicating the logic in the compact fast-path fallback.

582

#[allow(clippy::trivially_copy_pass_by_ref)] // <=8B Copy param kept by-ref intentionally (hot pixel/coord path or to avoid churning call sites for a perf-neutral change)

583

3

fn flex_basis_slow_path(

584

3

    cache: &azul_core::prop_cache::CssPropertyCache,

585

3

    node_data: &azul_core::dom::NodeData,

586

3

    id: &NodeId,

587

3

    node_state: &azul_core::styled_dom::StyledNodeState,

588

3

    taffy_style: &mut Style,

589

3

) -> Dimension {

590

3

    cache

591

3

        .get_property(node_data, id, node_state, &CssPropertyType::FlexBasis)

592

3

        .and_then(|p| {

593

            if let CssProperty::FlexBasis(v) = p {

594

                let basis = match v.get_property_or_default().unwrap_or_default() {

595

                    LayoutFlexBasis::Auto => Dimension::auto(),

596

                    LayoutFlexBasis::Exact(pv) => pixel_value_to_pixels_fallback(&pv)

597

                        .map(Dimension::length)

598

                        .or_else(|| pv.to_percent().map(|p| Dimension::percent(p.get())))

599

                        .unwrap_or_else(Dimension::auto),

600

};

601

                // WORKAROUND: If flex-basis is set and not auto, clear width to let flex-basis

602

                // take precedence. Workaround for Taffy not properly prioritizing flex-basis over width

603

                if !matches!(basis, auto if auto == Dimension::auto()) {

604

                    taffy_style.size.width = Dimension::auto();

605

606

                Some(basis)

607

            } else {

608

                None

609

610

})

611

3

        .unwrap_or_else(Dimension::auto)

612

3

613

614

/// The bridge struct that implements Taffy's traits.

615

/// It holds mutable references to the solver's data structures, allowing Taffy

616

/// to read styles and write layout results back into our `LayoutTree`.

617

struct TaffyBridge<'a, 'b, T: ParsedFontTrait> {

618

    ctx: &'a mut LayoutContext<'b, T>,

619

    tree: &'a mut LayoutTree,

620

    /// Raw pointer to text cache - needed because we can't have multiple &mut references

621

    /// SAFETY: This pointer is only valid for the lifetime of the `TaffyBridge`

622

    /// and must only be used within `compute_child_layout` callbacks

623

    text_cache: *mut crate::font_traits::TextLayoutCache,

624

    /// Heap-pinned `CalcResolveContext`s whose addresses are passed into taffy

625

    /// `Dimension::calc(ptr)`. Kept alive for the duration of the layout pass.

626

    /// Uses `RefCell` because `get_core_container_style` takes `&self`.

627

    // Box gives each CalcResolveContext a stable heap address for the `*const` handed to

628

    // taffy `Dimension::calc()`; a plain Vec<T> would invalidate those pointers on realloc.

629

    #[allow(clippy::vec_box)]

630

    calc_storage: std::cell::RefCell<Vec<Box<CalcResolveContext>>>,

631

    /// Memoised `translate_style_to_taffy` results, keyed by DOM node id

632

    /// (`usize` = `NodeId::index`). Taffy calls

633

    /// `get_core_container_style` and `should_suppress_cross_intrinsic`

634

    /// many times per node during a single layout pass; each call

635

    /// triggers ~13 `cache.get_property` cascade walks for grid/flex

636

    /// props. Caching the built `Style` cuts this to one build per node.

637

    style_memo: std::cell::RefCell<HashMap<usize, Style>>,

638

639

640

impl<'a, 'b, T: ParsedFontTrait> TaffyBridge<'a, 'b, T> {

641

1937

    fn new(

642

1937

        ctx: &'a mut LayoutContext<'b, T>,

643

1937

        tree: &'a mut LayoutTree,

644

1937

        text_cache: *mut crate::font_traits::TextLayoutCache,

645

1937

    ) -> Self {

646

1937

        Self {

647

1937

            ctx,

648

1937

            tree,

649

1937

            text_cache,

650

1937

            calc_storage: std::cell::RefCell::new(Vec::new()),

651

1937

            style_memo: std::cell::RefCell::new(HashMap::new()),

652

1937

653

1937

654

655

    /// Cache-backed wrapper for `translate_style_to_taffy`. Returns a

656

    /// clone of the memoised `Style` on cache hit, builds + inserts on

657

    /// miss. Keyed by DOM node index (not tree index) because the

658

    /// result depends only on the styled DOM, not on the transient

659

    /// layout tree.

660

9549816

    fn translate_style_to_taffy_cached(&self, dom_id: Option<NodeId>) -> Style {

661

9549816

        let Some(id) = dom_id else {

662

            return Style::default();

663

};

664

9549816

        let key = id.index();

665

9549816

        if let Some(style) = self.style_memo.borrow().get(&key) {

666

9438429

            return style.clone();

667

111387

668

111387

        let style = self.translate_style_to_taffy(dom_id);

669

111387

        self.style_memo.borrow_mut().insert(key, style.clone());

670

111387

        style

671

9549816

672

673

    /// Translates CSS properties from the `StyledDom` into a `taffy::Style` struct.

674

    /// This is the core of the integration, mapping one style system to another.

675

    #[allow(clippy::field_reassign_with_default)] // struct built incrementally / test setup; a struct literal is not clearer here

676

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

677

111387

    fn translate_style_to_taffy(&self, dom_id: Option<NodeId>) -> Style {

678

111387

        let Some(id) = dom_id else {

679

            return Style::default();

680

};

681

111387

        let styled_dom = &self.ctx.styled_dom;

682

111387

        let node_data = &styled_dom.node_data.as_ref()[id.index()];

683

111387

        let node_state = &styled_dom.styled_nodes.as_container()[id].styled_node_state;

684

111387

        let cache = &styled_dom.css_property_cache.ptr;

685

111387

        let mut taffy_style = Style::default();

686

687

        // Box Sizing — CSS default is content-box, but Taffy defaults to border-box

688

111387

        taffy_style.box_sizing = match get_css_box_sizing(styled_dom, id, node_state).unwrap_or_default() {

689

43092

            azul_css::props::layout::LayoutBoxSizing::BorderBox => BoxSizing::BorderBox,

690

68295

            azul_css::props::layout::LayoutBoxSizing::ContentBox => BoxSizing::ContentBox,

691

};

692

693

        // Display Mode

694

111387

        taffy_style.display =

695

111387

            layout_display_to_taffy(CssPropertyValue::Exact(get_display_type(styled_dom, id)));

696

697

        // Position

698

111387

        taffy_style.position =

699

111387

            from_layout_position(get_position(styled_dom, id, node_state).unwrap_or_default());

700

701

        // Inset (top, left, bottom, right)

702

111387

        taffy_style.inset = Rect {

703

111387

            left: multi_value_to_lpa(get_css_left(styled_dom, id, node_state)),

704

111387

            right: multi_value_to_lpa(get_css_right(styled_dom, id, node_state)),

705

111387

            top: multi_value_to_lpa(get_css_top(styled_dom, id, node_state)),

706

111387

            bottom: multi_value_to_lpa(get_css_bottom(styled_dom, id, node_state)),

707

111387

};

708

709

        // Size

710

111387

        let width = get_css_width(self.ctx.styled_dom, id, node_state);

711

111387

        let height = get_css_height(self.ctx.styled_dom, id, node_state);

712

713

        // Resolve node-local font sizes for calc() em/rem resolution

714

111387

        let em_size = crate::solver3::getters::get_element_font_size(styled_dom, id, node_state);

715

111387

        let rem_size = {

716

111387

            let root_id = NodeId::new(0);

717

111387

            let root_state = &styled_dom.styled_nodes.as_container()[root_id].styled_node_state;

718

111387

            crate::solver3::getters::get_element_font_size(styled_dom, root_id, root_state)

719

};

720

721

111387

        let taffy_width = from_layout_width(width.unwrap_or_default(), &self.calc_storage, em_size, rem_size);

722

111387

        let taffy_height = from_layout_height(height.unwrap_or_default(), &self.calc_storage, em_size, rem_size);

723

724

111387

        taffy_style.size = Size {

725

111387

            width: taffy_width,

726

111387

            height: taffy_height,

727

111387

};

728

729

        // Overflow — CRITICAL for scroll containers.

730

        // Without this, Taffy's flexbox algorithm uses content size as automatic

731

        // minimum size, causing flex containers with overflow:auto/scroll to

732

        // expand to fit all content instead of clipping at the explicit size.

733

        // With overflow: Hidden/Scroll, Taffy sets automatic min size to 0 and

734

        // constrains the container.

735

111387

        let overflow_x = get_overflow_x(styled_dom, id, node_state);

736

111387

        let overflow_y = get_overflow_y(styled_dom, id, node_state);

737

111387

        taffy_style.overflow = taffy::Point {

738

111387

            x: azul_overflow_to_taffy(overflow_x),

739

111387

            y: azul_overflow_to_taffy(overflow_y),

740

111387

};

741

742

        // Forward CSS aspect-ratio to taffy so flex/grid items honor it (and taffy's

743

        // transferred min-size suggestion works). AspectRatioValue stores width and

744

        // height ×1000, so the preferred ratio is simply width/height.

745

        #[allow(clippy::cast_precision_loss)] // small integer aspect-ratio components (e.g. 2000/1000)

746

747

111387

            taffy_style.aspect_ratio = match crate::solver3::getters::get_aspect_ratio_property(

748

111387

                styled_dom, id, node_state,

749

) {

750

                MultiValue::Exact(azul_css::props::style::effects::StyleAspectRatio::Ratio(ar))

751

                    if ar.height != 0 =>

752

753

                    Some(ar.width as f32 / ar.height as f32)

754

755

111387

                _ => None,

756

};

757

758

759

        // Min/Max Size

760

        // min-size:auto enables Taffy's auto minimum size algorithm which computes the

761

        // content size suggestion (min-content in main axis) and transferred size suggestion

762

        // (cross size converted through aspect ratio, if any). NOTE: aspect_ratio is not yet

763

        // forwarded to Taffy, so the transferred size suggestion path is incomplete.

764

        // NOTE: In CSS, the default min-width/min-height for flex items is `auto`

765

        // (which resolves to `min-content`), preventing them from shrinking below

766

        // their content size. We must map Auto to Dimension::Auto, NOT to 0px.

767

111387

        let min_width_css = get_css_min_width(styled_dom, id, node_state);

768

111387

        let min_height_css = get_css_min_height(styled_dom, id, node_state);

769

770

        taffy_style.min_size = Size {

771

111387

            width: match min_width_css {

772

                MultiValue::Auto | MultiValue::Initial | MultiValue::Inherit => {

773

106374

                    Dimension::auto()

774

775

5013

                MultiValue::Exact(v) => pixel_to_lp(v.inner).into(),

776

},

777

111387

            height: match min_height_css {

778

                MultiValue::Auto | MultiValue::Initial | MultiValue::Inherit => {

779

111315

                    Dimension::auto()

780

781

72

                MultiValue::Exact(v) => pixel_to_lp(v.inner).into(),

782

},

783

};

784

785

        // For max-size, we need to handle Auto specially - it should translate to Taffy's auto, not

786

        // a concrete value This is CRITICAL for flexbox stretch to work: items with

787

        // max-height: auto CAN be stretched

788

111387

        let max_width_css = get_css_max_width(styled_dom, id, node_state);

789

111387

        let max_height_css = get_css_max_height(styled_dom, id, node_state);

790

791

        taffy_style.max_size = Size {

792

111387

            width: match max_width_css {

793

                MultiValue::Auto | MultiValue::Initial | MultiValue::Inherit => {

794

111378

                    Dimension::auto()

795

796

9

                MultiValue::Exact(v) => pixel_to_lp(v.inner).into(),

797

},

798

111387

            height: match max_height_css {

799

                MultiValue::Auto | MultiValue::Initial | MultiValue::Inherit => {

800

111387

                    Dimension::auto()

801

802

                MultiValue::Exact(v) => pixel_to_lp(v.inner).into(),

803

},

804

};

805

806

        // Box Model (margin, padding, border)

807

111387

        let margin_left_css = get_css_margin_left(styled_dom, id, node_state);

808

111387

        let margin_right_css = get_css_margin_right(styled_dom, id, node_state);

809

111387

        let margin_top_css = get_css_margin_top(styled_dom, id, node_state);

810

111387

        let margin_bottom_css = get_css_margin_bottom(styled_dom, id, node_state);

811

812

111387

        taffy_style.margin = Rect {

813

111387

            left: multi_value_to_lpa_margin(margin_left_css),

814

111387

            right: multi_value_to_lpa_margin(margin_right_css),

815

111387

            top: multi_value_to_lpa_margin(margin_top_css),

816

111387

            bottom: multi_value_to_lpa_margin(margin_bottom_css),

817

111387

};

818

819

111387

        taffy_style.padding = Rect {

820

111387

            left: multi_value_to_lp(get_css_padding_left(styled_dom, id, node_state)),

821

111387

            right: multi_value_to_lp(get_css_padding_right(styled_dom, id, node_state)),

822

111387

            top: multi_value_to_lp(get_css_padding_top(styled_dom, id, node_state)),

823

111387

            bottom: multi_value_to_lp(get_css_padding_bottom(styled_dom, id, node_state)),

824

111387

};

825

826

111387

        taffy_style.border = Rect {

827

111387

            left: multi_value_to_lp(get_css_border_left_width(styled_dom, id, node_state)),

828

111387

            right: multi_value_to_lp(get_css_border_right_width(styled_dom, id, node_state)),

829

111387

            top: multi_value_to_lp(get_css_border_top_width(styled_dom, id, node_state)),

830

111387

            bottom: multi_value_to_lp(get_css_border_bottom_width(styled_dom, id, node_state)),

831

111387

};

832

833

        // Grid & gap properties — COMPACT FAST PATH: row_gap/column_gap are

834

        // i16 px × 10 in tier2_dims. The slow-path lookup would walk the

835

        // cascade for every node even though the answer is already encoded.

836

111387

        taffy_style.gap = cache.compact_cache.as_ref().map_or_else(|| cache

837

                .get_property(node_data, &id, node_state, &CssPropertyType::Gap)

838

                .and_then(|p| if let CssProperty::Gap(v) = p { Some(v) } else { None })

839

                .map_or_else(Size::zero, |v| {

840

                    let val = v.get_property_or_default().unwrap_or_default().inner;

841

                    let gap_lp = pixel_to_lp(val);

842

                    Size { width: gap_lp, height: gap_lp }

843

111387

                }), |cc| {

844

111387

            let row = cc.tier2_dims[id.index()].row_gap;

845

111387

            let col = cc.tier2_dims[id.index()].column_gap;

846

222774

            let decode = |raw: i16| -> LengthPercentage {

847

222774

                if raw >= azul_css::compact_cache::I16_SENTINEL_THRESHOLD {

848

                    LengthPercentage::length(0.0)

849

                } else {

850

222774

                    LengthPercentage::length(f32::from(raw) / 10.0)

851

852

222774

};

853

111387

            Size {

854

111387

                width: decode(col),

855

111387

                height: decode(row),

856

111387

857

111387

});

858

859

        // Skip grid properties when not in a grid context.

860

        // Grid container props: only if this node has display:grid.

861

        // Grid item props: only if parent has display:grid.

862

111387

        let (self_is_grid, parent_is_grid) = cache.compact_cache.as_ref().map_or((false, false), |cc| {

863

            #[allow(clippy::wildcard_imports)] // widget/render module pulls in the css property/value types it builds with

864

            use azul_css::compact_cache::*;

865

111387

            let self_t1 = cc.tier1_enums[id.index()];

866

111387

            let self_display = ((self_t1 >> DISPLAY_SHIFT) & DISPLAY_MASK) as u8;

867

111387

            let grid_val = layout_display_to_u8(LayoutDisplay::Grid);

868

111387

            let self_grid = self_display == grid_val;

869

870

111387

            let parent_idx = styled_dom.node_hierarchy.as_ref()[id.index()].parent_id()

871

111387

                .map_or(0, |p| p.index());

872

111387

            let parent_t1 = cc.tier1_enums[parent_idx];

873

111387

            let parent_display = ((parent_t1 >> DISPLAY_SHIFT) & DISPLAY_MASK) as u8;

874

111387

            let parent_grid = parent_display == grid_val;

875

111387

            (self_grid, parent_grid)

876

111387

});

877

878

111387

        if self_is_grid {

879

27

        taffy_style.grid_template_rows = cache

880

27

            .get_property(

881

27

                node_data,

882

27

                &id,

883

27

                node_state,

884

27

                &CssPropertyType::GridTemplateRows,

885

27

886

27

            .and_then(|p| {

887

27

                if let CssProperty::GridTemplateRows(v) = p {

888

27

                    Some(v.clone())

889

                } else {

890

                    None

891

892

27

})

893

27

            .map(grid_template_rows_to_taffy)

894

27

            .unwrap_or_default();

895

896

        // Grid template columns - convert GridTemplate to Vec<GridTemplateComponent>

897

27

        taffy_style.grid_template_columns = cache

898

27

            .get_property(

899

27

                node_data,

900

27

                &id,

901

27

                node_state,

902

27

                &CssPropertyType::GridTemplateColumns,

903

27

904

27

            .and_then(|p| {

905

27

                if let CssProperty::GridTemplateColumns(v) = p {

906

27

                    Some(v.clone())

907

                } else {

908

                    None

909

910

27

})

911

27

            .map(grid_template_columns_to_taffy)

912

27

            .unwrap_or_default();

913

914

        // Grid template areas - convert GridTemplateAreas to Vec<taffy::GridTemplateArea<String>>

915

27

        taffy_style.grid_template_areas = cache

916

27

            .get_property(

917

27

                node_data,

918

27

                &id,

919

27

                node_state,

920

27

                &CssPropertyType::GridTemplateAreas,

921

27

922

27

            .and_then(|p| {

923

9

                if let CssProperty::GridTemplateAreas(v) = p {

924

9

                    v.get_property().cloned()

925

                } else {

926

                    None

927

928

9

})

929

27

            .map(|areas| {

930

9

                areas

931

9

                    .areas

932

9

                    .as_ref()

933

9

                    .iter()

934

9

                    .map(|a| taffy::GridTemplateArea {

935

45

                        name: a.name.as_str().to_string(),

936

45

                        row_start: a.row_start,

937

45

                        row_end: a.row_end,

938

45

                        column_start: a.column_start,

939

45

                        column_end: a.column_end,

940

45

})

941

9

                    .collect::<Vec<_>>()

942

9

})

943

27

            .unwrap_or_default();

944

945

27

        taffy_style.grid_auto_rows = cache

946

27

            .get_property(node_data, &id, node_state, &CssPropertyType::GridAutoRows)

947

27

            .and_then(|p| {

948

                if let CssProperty::GridAutoRows(v) = p {

949

                    Some(v.clone())

950

                } else {

951

                    None

952

953

})

954

27

            .map(grid_auto_rows_to_taffy)

955

27

            .unwrap_or_default();

956

957

27

        taffy_style.grid_auto_columns = cache

958

27

            .get_property(

959

27

                node_data,

960

27

                &id,

961

27

                node_state,

962

27

                &CssPropertyType::GridAutoColumns,

963

27

964

27

            .and_then(|p| {

965

                if let CssProperty::GridAutoColumns(v) = p {

966

                    Some(v.clone())

967

                } else {

968

                    None

969

970

})

971

27

            .map(grid_auto_columns_to_taffy)

972

27

            .unwrap_or_default();

973

974

27

        taffy_style.grid_auto_flow = cache.compact_cache.as_ref().map_or_else(|| cache

975

                .get_property(node_data, &id, node_state, &CssPropertyType::GridAutoFlow)

976

                .and_then(|p| if let CssProperty::GridAutoFlow(v) = p { Some(*v) } else { None })

977

                .map(grid_auto_flow_to_taffy)

978

27

                .unwrap_or_default(), |cc| {

979

            #[allow(clippy::wildcard_imports)] // widget/render module pulls in the css property/value types it builds with

980

            use azul_css::compact_cache::*;

981

27

            let bits = ((cc.tier1_enums[id.index()] >> GRID_AUTO_FLOW_SHIFT) & GRID_AUTO_FLOW_MASK) as u8;

982

27

            let val = layout_grid_auto_flow_from_u8(bits);

983

27

            grid_auto_flow_to_taffy(CssPropertyValue::Exact(val))

984

27

});

985

986

111360

        } // end if self_is_grid

987

988

111387

        if parent_is_grid {

989

        // Grid item placement. The compact cold cache holds Auto/Line/Span as

990

        // an i16; NAMED lines and areas (`grid-area: header`) cannot be

991

        // encoded there and are stored as I16_SENTINEL — for those the REAL

992

        // property must be consulted, per axis. Decoding the sentinel as

993

        // Auto silently discarded every named placement, which auto-flowed

994

        // all grid-template-areas layouts (grid-template-areas-001).

995

99

        let slow_grid_column = || {

996

45

            cache

997

45

                .get_property(node_data, &id, node_state, &CssPropertyType::GridColumn)

998

45

                .and_then(|p| if let CssProperty::GridColumn(v) = p { v.get_property().cloned() } else { None })

999

45

};

1000

99

        let slow_grid_row = || {

1001

45

            cache

1002

45

                .get_property(node_data, &id, node_state, &CssPropertyType::GridRow)

1003

45

                .and_then(|p| if let CssProperty::GridRow(v) = p { v.get_property().cloned() } else { None })

1004

45

};

1005

99

        if let Some(cc) = cache.compact_cache.as_ref() {

1006

            use azul_css::compact_cache::{I16_AUTO, I16_SENTINEL};

1007

99

            let cold = &cc.tier2_cold[id.index()];

1008

99

            let (cs, ce) = (cold.grid_col_start, cold.grid_col_end);

1009

99

            if cs == I16_SENTINEL || ce == I16_SENTINEL {

1010

45

                if let Some(grid_col) = slow_grid_column() {

1011

45

                    taffy_style.grid_column = grid_placement_to_taffy(&grid_col);

1012

45

1013

54

            } else if cs != I16_AUTO || ce != I16_AUTO {

1014

                taffy_style.grid_column = Line { start: decode_compact_grid_line(cs), end: decode_compact_grid_line(ce) };

1015

54

1016

99

            let (rs, re) = (cold.grid_row_start, cold.grid_row_end);

1017

99

            if rs == I16_SENTINEL || re == I16_SENTINEL {

1018

45

                if let Some(grid_row) = slow_grid_row() {

1019

45

                    taffy_style.grid_row = grid_placement_to_taffy(&grid_row);

1020

45

1021

54

            } else if rs != I16_AUTO || re != I16_AUTO {

1022

                taffy_style.grid_row = Line { start: decode_compact_grid_line(rs), end: decode_compact_grid_line(re) };

1023

54

1024

        } else {

1025

            if let Some(grid_col) = slow_grid_column() {

1026

                taffy_style.grid_column = grid_placement_to_taffy(&grid_col);

1027

1028

            if let Some(grid_row) = slow_grid_row() {

1029

                taffy_style.grid_row = grid_placement_to_taffy(&grid_row);

1030

1031

1032

111288

        } // end if parent_is_grid

1033

1034

        // Flexbox

1035

111387

        taffy_style.flex_direction = match get_flex_direction(styled_dom, id, node_state) {

1036

111384

            MultiValue::Exact(v) => layout_flex_direction_to_taffy(CssPropertyValue::Exact(v)),

1037

3

            _ => FlexDirection::Row,

1038

};

1039

        // COMPACT FAST PATH: flex_wrap is Tier 1 enum

1040

        taffy_style.flex_wrap = {

1041

111387

            let compact = if node_state.is_normal() {

1042

111384

                cache.compact_cache.as_ref().map(|cc| {

1043

111384

                    layout_flex_wrap_to_taffy(CssPropertyValue::Exact(cc.get_flex_wrap(id.index())))

1044

111384

})

1045

            } else {

1046

3

                None

1047

};

1048

111387

            compact.unwrap_or_else(|| {

1049

3

                cache

1050

3

                    .get_property(node_data, &id, node_state, &CssPropertyType::FlexWrap)

1051

3

                    .and_then(|p| if let CssProperty::FlexWrap(v) = p { Some(*v) } else { None })

1052

3

                    .map_or(FlexWrap::NoWrap, layout_flex_wrap_to_taffy)

1053

3

})

1054

};

1055

111387

        taffy_style.align_items = match get_align_items(styled_dom, id, node_state) {

1056

111384

            MultiValue::Exact(v) => Some(layout_align_items_to_taffy(CssPropertyValue::Exact(v))),

1057

3

            _ => None,

1058

};

1059

                // CSS spec: default align-items is "normal" which acts like "stretch"

1060

                // for non-replaced grid/flex items. Taffy handles this internally when

1061

                // align_items is None, so we should NOT force a default here.

1062

111387

        taffy_style.justify_items = cache.compact_cache.as_ref().map_or_else(|| cache

1063

                .get_property(node_data, &id, node_state, &CssPropertyType::JustifyItems)

1064

                .and_then(|p| if let CssProperty::JustifyItems(v) = p { Some(*v) } else { None })

1065

111387

                .map(layout_justify_items_to_taffy), |cc| {

1066

            #[allow(clippy::wildcard_imports)] // widget/render module pulls in the css property/value types it builds with

1067

            use azul_css::compact_cache::*;

1068

            use azul_css::props::layout::grid::LayoutJustifyItems;

1069

111387

            let bits = ((cc.tier1_enums[id.index()] >> JUSTIFY_ITEMS_SHIFT) & JUSTIFY_ITEMS_MASK) as u8;

1070

111387

            let val = layout_justify_items_from_u8(bits);

1071

111387

            Some(match val {

1072

                LayoutJustifyItems::Start => AlignItems::Start,

1073

                LayoutJustifyItems::End => AlignItems::End,

1074

                LayoutJustifyItems::Center => AlignItems::Center,

1075

111387

                LayoutJustifyItems::Stretch => AlignItems::Stretch,

1076

})

1077

111387

});

1078

        // COMPACT FAST PATH: justify-content is in tier1 bits 21-23.

1079

111387

        taffy_style.justify_content = cache.compact_cache.as_ref().map_or_else(|| cache

1080

                .get_property(node_data, &id, node_state, &CssPropertyType::JustifyContent)

1081

                .and_then(|p| if let CssProperty::JustifyContent(v) = p { Some(v) } else { None })

1082

111387

                .map(|v| layout_justify_content_to_taffy(*v)), |cc| {

1083

            #[allow(clippy::wildcard_imports)] // widget/render module pulls in the css property/value types it builds with

1084

            use azul_css::compact_cache::*;

1085

            use azul_css::props::layout::LayoutJustifyContent;

1086

111387

            let bits = ((cc.tier1_enums[id.index()] >> JUSTIFY_CONTENT_SHIFT) & JUSTIFY_MASK) as u8;

1087

111387

            Some(match layout_justify_content_from_u8(bits) {

1088

102585

                LayoutJustifyContent::FlexStart => JustifyContent::FlexStart,

1089

                LayoutJustifyContent::FlexEnd => JustifyContent::FlexEnd,

1090

                LayoutJustifyContent::Start => JustifyContent::Start,

1091

                LayoutJustifyContent::End => JustifyContent::End,

1092

8739

                LayoutJustifyContent::Center => JustifyContent::Center,

1093

63

                LayoutJustifyContent::SpaceBetween => JustifyContent::SpaceBetween,

1094

                LayoutJustifyContent::SpaceAround => JustifyContent::SpaceAround,

1095

                LayoutJustifyContent::SpaceEvenly => JustifyContent::SpaceEvenly,

1096

})

1097

111387

});

1098

                // CSS spec: default justify-content is "normal". Taffy handles

1099

                // this internally when justify_content is None.

1100

        // COMPACT FAST PATH: flex_grow stored as u16 × 100

1101

        taffy_style.flex_grow = {

1102

111387

            let compact = if node_state.is_normal() {

1103

111384

                cache.compact_cache.as_ref().and_then(|cc| cc.get_flex_grow(id.index()))

1104

            } else {

1105

3

                None

1106

};

1107

111387

            compact.unwrap_or_else(|| {

1108

3

                cache

1109

3

                    .get_property(node_data, &id, node_state, &CssPropertyType::FlexGrow)

1110

3

                    .and_then(|p| if let CssProperty::FlexGrow(v) = p {

1111

                        Some(v.get_property_or_default().unwrap_or_default().inner.get())

1112

                    } else { None })

1113

3

                    .unwrap_or(0.0)

1114

3

})

1115

};

1116

1117

        // COMPACT FAST PATH: flex_shrink stored as u16 × 100

1118

        taffy_style.flex_shrink = {

1119

111387

            let compact = if node_state.is_normal() {

1120

111384

                cache.compact_cache.as_ref().and_then(|cc| cc.get_flex_shrink(id.index()))

1121

            } else {

1122

3

                None

1123

};

1124

111387

            compact.unwrap_or_else(|| {

1125

3

                cache

1126

3

                    .get_property(node_data, &id, node_state, &CssPropertyType::FlexShrink)

1127

3

                    .and_then(|p| if let CssProperty::FlexShrink(v) = p {

1128

                        Some(v.get_property_or_default().unwrap_or_default().inner.get())

1129

                    } else { None })

1130

3

                    .unwrap_or(1.0)

1131

3

})

1132

};

1133

        // COMPACT FAST PATH: flex_basis stored as u32 with PixelValue encoding

1134

        taffy_style.flex_basis = {

1135

111387

            let compact = if node_state.is_normal() {

1136

111384

                cache.compact_cache.as_ref().and_then(|cc| {

1137

111384

                    let raw = cc.get_flex_basis_raw(id.index());

1138

111384

                    match raw {

1139

                        azul_css::compact_cache::U32_AUTO

1140

                        | azul_css::compact_cache::U32_NONE

1141

111354

                        | azul_css::compact_cache::U32_INITIAL => Some(Dimension::auto()),

1142

                        azul_css::compact_cache::U32_SENTINEL

1143

                        | azul_css::compact_cache::U32_INHERIT => None,

1144

                        _ => {

1145

30

                            if let Some(pv) = azul_css::compact_cache::decode_pixel_value_u32(raw) {

1146

30

                                let basis = pixel_value_to_pixels_fallback(&pv)

1147

30

                                    .map(Dimension::length)

1148

30

                                    .or_else(|| pv.to_percent().map(|p| Dimension::percent(p.get())))

1149

30

                                    .unwrap_or_else(Dimension::auto);

1150

30

                                if !matches!(basis, auto if auto == Dimension::auto()) {

1151

30

                                    taffy_style.size.width = Dimension::auto();

1152

30

1153

30

                                Some(basis)

1154

                            } else {

1155

                                Some(Dimension::auto())

1156

1157

1158

1159

111384

})

1160

            } else {

1161

3

                None

1162

};

1163

111387

            compact.unwrap_or_else(|| {

1164

3

                flex_basis_slow_path(cache, node_data, &id, node_state, &mut taffy_style)

1165

3

})

1166

};

1167

111387

        taffy_style.align_self = cache.compact_cache.as_ref().map_or_else(|| cache

1168

                .get_property(node_data, &id, node_state, &CssPropertyType::AlignSelf)

1169

111387

                .and_then(|p| if let CssProperty::AlignSelf(v) = p { layout_align_self_to_taffy(*v) } else { None }), |cc| {

1170

            #[allow(clippy::wildcard_imports)] // widget/render module pulls in the css property/value types it builds with

1171

            use azul_css::compact_cache::*;

1172

111387

            let bits = ((cc.tier1_enums[id.index()] >> ALIGN_SELF_SHIFT) & ALIGN_SELF_MASK) as u8;

1173

111387

            let val = layout_align_self_from_u8(bits);

1174

111387

            match val {

1175

111377

                LayoutAlignSelf::Auto => None,

1176

                LayoutAlignSelf::Start => Some(AlignSelf::FlexStart),

1177

9

                LayoutAlignSelf::End => Some(AlignSelf::FlexEnd),

1178

                LayoutAlignSelf::Center => Some(AlignSelf::Center),

1179

                LayoutAlignSelf::Baseline => Some(AlignSelf::Baseline),

1180

1

                LayoutAlignSelf::Stretch => Some(AlignSelf::Stretch),

1181

1182

111387

});

1183

111387

        taffy_style.justify_self = cache.compact_cache.as_ref().map_or_else(|| cache

1184

                .get_property(node_data, &id, node_state, &CssPropertyType::JustifySelf)

1185

                .and_then(|p| if let CssProperty::JustifySelf(v) = p {

1186

                    use azul_css::props::layout::grid::LayoutJustifySelf;

1187

                    match v.get_property_or_default().unwrap_or_default() {

1188

                        LayoutJustifySelf::Auto => None,

1189

                        LayoutJustifySelf::Start => Some(AlignSelf::Start),

1190

                        LayoutJustifySelf::End => Some(AlignSelf::End),

1191

                        LayoutJustifySelf::Center => Some(AlignSelf::Center),

1192

                        LayoutJustifySelf::Stretch => Some(AlignSelf::Stretch),

1193

1194

111387

                } else { None }), |cc| {

1195

            #[allow(clippy::wildcard_imports)] // widget/render module pulls in the css property/value types it builds with

1196

            use azul_css::compact_cache::*;

1197

            use azul_css::props::layout::grid::LayoutJustifySelf;

1198

111387

            let bits = ((cc.tier1_enums[id.index()] >> JUSTIFY_SELF_SHIFT) & JUSTIFY_SELF_MASK) as u8;

1199

111387

            let val = layout_justify_self_from_u8(bits);

1200

111387

            match val {

1201

111387

                LayoutJustifySelf::Auto => None,

1202

                LayoutJustifySelf::Start => Some(AlignSelf::Start),

1203

                LayoutJustifySelf::End => Some(AlignSelf::End),

1204

                LayoutJustifySelf::Center => Some(AlignSelf::Center),

1205

                LayoutJustifySelf::Stretch => Some(AlignSelf::Stretch),

1206

1207

111387

});

1208

111387

        taffy_style.align_content = match get_align_content(styled_dom, id, node_state) {

1209

111384

            MultiValue::Exact(v) => Some(layout_align_content_to_taffy(CssPropertyValue::Exact(v))),

1210

3

            _ => None,

1211

};

1212

                // CSS spec: default align-content is "normal". Taffy handles

1213

                // this internally when align_content is None.

1214

1215

111387

        taffy_style

1216

111387

1217

1218

    /// Gets or computes the Taffy style for a given node index.

1219

4778009

    fn get_taffy_style(&self, node_idx: usize) -> Style {

1220

4778009

        let dom_id = self.tree.get(LayoutNodeId::new(node_idx)).and_then(|n| n.dom_node_id);

1221

4778009

        let mut style = self.translate_style_to_taffy_cached(dom_id);

1222

1223

        // CSS 2.1 § 10.3.3: Root element margin handling for Flex/Grid.

1224

//

1225

        // The root element's margin is already resolved and subtracted from

1226

        // available_size by calculate_used_size_for_node() (sizing.rs). The

1227

        // resulting margin-adjusted size is passed to Taffy as known_dimensions.

1228

//

1229

        // Taffy's layout algorithm reads margin from the style and subtracts it

1230

        // from known_dimensions internally. If we also pass the margin through

1231

        // the style, it gets subtracted twice:

1232

        //   1. calculate_used_size_for_node: viewport - margin → available_size

1233

        //   2. Taffy: known_dimensions - style.margin → content_area

1234

//

1235

        // Zeroing the style margin for root nodes prevents this double-subtraction.

1236

        // This is NOT a hack — it's the correct integration point between Azul's

1237

        // BFC-level sizing and Taffy's Flex/Grid algorithm.

1238

4778009

        let is_root = self.tree.get(LayoutNodeId::new(node_idx)).is_some_and(|n| n.parent.is_none());

1239

4778009

        if is_root {

1240

1183

            style.margin = Rect::zero();

1241

4776826

1242

1243

        // FIX: Apply cross-axis intrinsic size suppression for stretch alignment.

1244

        // This enables align-self: stretch to work correctly by ensuring Taffy

1245

        // sees the cross-axis size as Auto (allowing stretch) rather than a definite value.

1246

4778009

        let (suppress_width, suppress_height) = self.should_suppress_cross_intrinsic(node_idx, &style);

1247

1248

4778009

        if suppress_width {

1249

687372

            // Force width to Auto and set min-width to 0 to allow stretching.

1250

687372

            // Taffy treats Auto size + Stretch alignment as a signal to fill the container.

1251

687372

            style.size.width = Dimension::auto();

1252

687372

            style.min_size.width = Dimension::length(0.0);

1253

4090637

1254

1255

4778009

        if suppress_height {

1256

855885

            style.size.height = Dimension::auto();

1257

855885

            style.min_size.height = Dimension::length(0.0);

1258

3922124

1259

1260

4778009

        style

1261

4778009

1262

1263

    /// Determines if cross-axis intrinsic size should be suppressed for stretching.

1264

///

1265

    /// Per CSS Flexbox spec, align-items: stretch makes items fill the cross-axis

1266

    /// ONLY if the item's cross-size is 'auto' AND the item has no intrinsic cross-size.

1267

///

1268

    /// Returns (`suppress_width`, `suppress_height`) booleans.

1269

    #[allow(clippy::match_same_arms)] // enum/value mapping/dispatch table: one arm per input variant (or cross-type bindings that can't merge)

1270

4778009

    fn should_suppress_cross_intrinsic(&self, node_idx: usize, style: &Style) -> (bool, bool) {

1271

4778009

        let Some(node) = self.tree.get(LayoutNodeId::new(node_idx)) else {

1272

            return (false, false);

1273

};

1274

1275

        // Check if parent is a flex or grid container

1276

4778009

        let Some(parent_fc) = self.tree.warm(LayoutNodeId::new(node_idx)).and_then(|w| w.parent_formatting_context) else {

1277

1183

            return (false, false);

1278

};

1279

1280

4776826

        match parent_fc {

1281

            FormattingContext::Flex => {

1282

                // Get parent node to check its flex-direction and align-items

1283

4771807

                let Some(parent_idx) = node.parent else {

1284

                    return (false, false);

1285

};

1286

4771807

                let parent_dom_id = self.tree.get(LayoutNodeId::new(parent_idx)).and_then(|n| n.dom_node_id);

1287

4771807

                let parent_style = self.translate_style_to_taffy_cached(parent_dom_id);

1288

1289

                // Determine if flex container is row or column

1290

4771807

                let is_row = matches!(

1291

4771807

                    parent_style.flex_direction,

1292

                    FlexDirection::Row | FlexDirection::RowReverse

1293

);

1294

1295

                // Get effective align value for this item

1296

                // align-self overrides parent's align-items

1297

4771807

                let align = style

1298

4771807

                    .align_self

1299

4771807

                    .or(parent_style.align_items)

1300

4771807

                    .unwrap_or(AlignSelf::Stretch);

1301

1302

4771807

                let should_stretch = matches!(align, AlignSelf::Stretch);

1303

1304

4771807

                if !should_stretch {

1305

3065751

                    return (false, false);

1306

1706056

1307

1308

                // Check if cross-axis size is auto

1309

                // For row flex: cross-axis is height

1310

                // For column flex: cross-axis is width

1311

1706056

                let cross_size_is_auto = if is_row {

1312

929141

                    style.size.height == Dimension::auto()

1313

                } else {

1314

776915

                    style.size.width == Dimension::auto()

1315

};

1316

1317

1706056

                if !cross_size_is_auto {

1318

162799

                    return (false, false);

1319

1543257

1320

1321

                // All conditions met: suppress intrinsic cross-size

1322

1543257

                if is_row {

1323

855885

                    (false, true) // Suppress height for row flex

1324

                } else {

1325

687372

                    (true, false) // Suppress width for column flex

1326

1327

1328

            FormattingContext::Grid => {

1329

                // TODO: Implement grid stretch detection

1330

                // Grid is more complex because:

1331

                // 1. Default align-items is 'start', not 'stretch'

1332

                // 2. Items can stretch in both axes simultaneously

1333

                // 3. Need to check grid-auto-flow and track sizing

1334

1044

                (false, false)

1335

1336

3975

            _ => (false, false),

1337

1338

4778009

1339

1340

    /// Helper to get children that participate in layout (i.e., not `display: none`).

1341

695789

    fn get_layout_children(&self, node_idx: usize) -> Vec<usize> {

1342

        use crate::solver3::getters::{get_display_property, MultiValue};

1343

695789

        let Some(node) = self.tree.get(LayoutNodeId::new(node_idx)) else {

1344

            return Vec::new();

1345

};

1346

1347

695789

        self.tree.children(node_idx)

1348

695789

            .iter()

1349

1478115

            .filter(|&&child_idx| {

1350

1478115

                let Some(child_node) = self.tree.get(LayoutNodeId::new(child_idx)) else {

1351

                    return false;

1352

};

1353

1478115

                let Some(child_dom_id) = child_node.dom_node_id else {

1354

                    return true;

1355

};

1356

1357

                // Check if child has display: none

1358

1478115

                let display = get_display_property(self.ctx.styled_dom, Some(child_dom_id));

1359

1478115

                let is_display_none = matches!(display, MultiValue::Exact(LayoutDisplay::None));

1360

1361

1478115

                !is_display_none

1362

1478115

})

1363

695789

            .copied()

1364

695789

            .collect()

1365

695789

1366

1367

1368

/// Main entry point for laying out a Flexbox or Grid container using Taffy.

1369

///

1370

/// This function now accepts a `text_cache` parameter so that IFC layout can be

1371

/// performed inline during Taffy's measure callbacks, rather than as a post-processing step.

1372

/// # Panics

1373

///

1374

/// Panics if `node_idx` is not present in the layout tree.

1375

1937

pub fn layout_taffy_subtree<T: ParsedFontTrait>(

1376

1937

    ctx: &mut LayoutContext<'_, T>,

1377

1937

    tree: &mut LayoutTree,

1378

1937

    text_cache: &mut crate::font_traits::TextLayoutCache,

1379

1937

    node_idx: usize,

1380

1937

    inputs: LayoutInput,

1381

1937

) -> LayoutOutput {

1382

1937

    let children: Vec<usize> = tree.children(node_idx).to_vec();

1383

1384

    // DEBUG: Log Taffy inputs

1385

1937

    if ctx.debug_messages.is_some() {

1386

1900

        ctx.debug_info_inner(format!(

1387

1900

            "[TAFFY INPUT] node_idx={} known_dims=({:?}, {:?}) available=({:?}, {:?}) \

1388

1900

             parent_size=({:?}, {:?}) children={:?}",

1389

1900

            node_idx,

1390

1900

            inputs.known_dimensions.width,

1391

1900

            inputs.known_dimensions.height,

1392

1900

            inputs.available_space.width,

1393

1900

            inputs.available_space.height,

1394

1900

            inputs.parent_size.width,

1395

1900

            inputs.parent_size.height,

1396

1900

            children

1397

1900

));

1398

1900

1399

1400

    // NOTE (2026-08-08): the unconditional "clear every child's taffy_cache

1401

    // to force re-measure" that used to live here (Nov 2025, pre-reconcile)

1402

    // is GONE. Dirty-driven invalidation now happens once per pass in

1403

    // layout_document Step 1.2 over the ancestor closure of

1404

    // `intrinsic_dirty`; everything else is covered by taffy's own

1405

    // (known_dimensions, available_space, run_mode) cache key. The hammer

1406

    // was re-running full min/max-content subtree layouts for every flex

1407

    // child on every pass — 312 of them per steady-state resize on big.md,

1408

    // each re-breaking every IFC line in the subtree — and, worse, each

1409

    // measure STORE evicted the Definite entry in the single-slot IFC cache

1410

    // (`should_replace_with`: width type changed), so the final pass

1411

    // re-flowed the text AGAIN. Measured: root_layout_pass 25.5 ms → see

1412

    // scripts/ for the after numbers.

1413

1414

    // SAFETY: We pass text_cache as a raw pointer because TaffyBridge needs to call

1415

    // layout_ifc from within compute_child_layout, but we already have &mut ctx and &mut tree.

1416

    // The pointer is only valid for the duration of this function call.

1417

1937

    let text_cache_ptr = core::ptr::from_mut::<crate::font_traits::TextLayoutCache>(text_cache);

1418

1419

1937

    let mut bridge = TaffyBridge::new(ctx, tree, text_cache_ptr);

1420

1937

    let node = bridge.tree.get(LayoutNodeId::new(node_idx)).unwrap();

1421

1422

1937

    let output = match node.formatting_context {

1423

1910

        FormattingContext::Flex => compute_flexbox_layout(&mut bridge, node_idx.into(), inputs),

1424

27

        FormattingContext::Grid => compute_grid_layout(&mut bridge, node_idx.into(), inputs),

1425

        _ => LayoutOutput::HIDDEN,

1426

};

1427

1428

    // DEBUG: Log Taffy output

1429

1937

    if bridge.ctx.debug_messages.is_some() {

1430

1900

        bridge.ctx.debug_info_inner(format!(

1431

1900

            "[TAFFY OUTPUT] node_idx={} output_size=({:?}, {:?})",

1432

            node_idx, output.size.width, output.size.height

1433

));

1434

1435

        // Log child layout results

1436

5597

        for &child_idx in &children {

1437

3697

            if let Some(child) = bridge.tree.get(LayoutNodeId::new(child_idx)) {

1438

3697

                bridge.ctx.debug_info_inner(format!(

1439

3697

                    "[TAFFY CHILD RESULT] child_idx={} used_size={:?} relative_pos={:?}",

1440

3697

                    child_idx, child.used_size, bridge.tree.warm(LayoutNodeId::new(child_idx)).and_then(|w| w.relative_position)

1441

));

1442

1443

1444

37

1445

1446

1937

    output

1447

1937

1448

1449

// --- Trait Implementations for the Bridge ---

1450

1451

impl<T: ParsedFontTrait> TraversePartialTree for TaffyBridge<'_, '_, T> {

1452

    type ChildIter<'c>

1453

        = std::vec::IntoIter<taffy::NodeId>

1454

    where

1455

        Self: 'c;

1456

1457

362524

    fn child_ids(&self, node_id: taffy::NodeId) -> Self::ChildIter<'_> {

1458

362524

        let node_idx: usize = node_id.into();

1459

362524

        let children = self.get_layout_children(node_idx);

1460

362524

        children

1461

362524

            .into_iter()

1462

362524

            .map(Into::into)

1463

362524

            .collect::<Vec<taffy::NodeId>>()

1464

362524

            .into_iter()

1465

362524

1466

1467

114464

    fn child_count(&self, node_id: taffy::NodeId) -> usize {

1468

114464

        let node_idx: usize = node_id.into();

1469

1470

114464

        self.get_layout_children(node_idx).len()

1471

114464

1472

1473

218801

    fn get_child_id(&self, node_id: taffy::NodeId, index: usize) -> taffy::NodeId {

1474

218801

        self.get_layout_children(node_id.into())[index].into()

1475

218801

1476

1477

1478

impl<T: ParsedFontTrait> LayoutPartialTree for TaffyBridge<'_, '_, T> {

1479

    type CoreContainerStyle<'c>

1480

        = Style

1481

    where

1482

        Self: 'c;

1483

    type CustomIdent = String;

1484

1485

2990339

    fn get_core_container_style(&self, node_id: taffy::NodeId) -> Self::CoreContainerStyle<'_> {

1486

2990339

        let node_idx: usize = node_id.into();

1487

        // Use get_taffy_style instead of translate_style_to_taffy to apply

1488

        // cross-axis intrinsic suppression for stretch alignment

1489

2990339

        self.get_taffy_style(node_idx)

1490

2990339

1491

1492

109450

    fn set_unrounded_layout(&mut self, node_id: taffy::NodeId, layout: &Layout) {

1493

109450

        let node_idx: usize = node_id.into();

1494

1495

        // FIX: Retrieve parent border/padding to adjust position.

1496

        // Taffy positions are relative to the parent's Border Box origin.

1497

        // Azul expects positions relative to the parent's Content Box origin.

1498

        // We must subtract the parent's border and padding from the Taffy-returned position.

1499

109450

        let (parent_border_left, parent_border_top, parent_padding_left, parent_padding_top) = {

1500

109450

            if let Some(child) = self.tree.get(LayoutNodeId::new(node_idx)) {

1501

109450

                if let Some(parent_idx) = child.parent {

1502

109450

                    self.tree.get(LayoutNodeId::new(parent_idx)).map_or((0.0, 0.0, 0.0, 0.0), |parent| {

1503

109450

                        let pbp = parent.box_props.unpack();

1504

109450

1505

109450

                            pbp.border.left,

1506

109450

                            pbp.border.top,

1507

109450

                            pbp.padding.left,

1508

109450

                            pbp.padding.top,

1509

109450

1510

109450

})

1511

                } else {

1512

                    (0.0, 0.0, 0.0, 0.0)

1513

1514

            } else {

1515

                (0.0, 0.0, 0.0, 0.0)

1516

1517

};

1518

1519

109450

        if let Some(node) = self.tree.get_mut(LayoutNodeId::new(node_idx)) {

1520

109450

            let size = translate_taffy_size_back(layout.size);

1521

109450

            let mut pos = translate_taffy_point_back(layout.location);

1522

1523

            // DEBUG: Log Taffy's raw layout result before adjustment

1524

109450

            if self.ctx.debug_messages.is_some() {

1525

109367

                self.ctx.debug_info_inner(format!(

1526

109367

                    "[TAFFY set_unrounded_layout] node_idx={} taffy_size=({:.2}, {:.2}) \

1527

109367

                     taffy_pos=({:.2}, {:.2}) parent_border=({:.2}, {:.2}) parent_padding=({:.2}, \

1528

109367

                     {:.2})",

1529

109367

                    node_idx,

1530

109367

                    layout.size.width,

1531

109367

                    layout.size.height,

1532

109367

                    layout.location.x,

1533

109367

                    layout.location.y,

1534

109367

                    parent_border_left,

1535

109367

                    parent_border_top,

1536

109367

                    parent_padding_left,

1537

109367

                    parent_padding_top

1538

109367

));

1539

109367

1540

1541

            // Subtract parent's border and padding offset to convert

1542

            // from border-box-relative to content-box-relative position

1543

109450

            pos.x -= parent_border_left + parent_padding_left;

1544

109450

            pos.y -= parent_border_top + parent_padding_top;

1545

1546

109450

            node.used_size = Some(size);

1547

1548

109450

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

1549

109450

            let mut pos = translate_taffy_point_back(layout.location);

1550

109450

            pos.x -= parent_border_left + parent_padding_left;

1551

109450

            pos.y -= parent_border_top + parent_padding_top;

1552

109450

            warm.relative_position = Some(pos);

1553

109450

1554

109450

1555

1556

    fn resolve_calc_value(&self, val: *const (), basis: f32) -> f32 {

1557

        // SAFETY: `val` came from `store_calc_and_make_dimension` which stored

1558

        // a `Box<CalcResolveContext>` in `self.calc_storage`. The Box is alive for

1559

        // the lifetime of this TaffyBridge, and taffy only clears the low 3 bits.

1560

        let ctx = unsafe { &*val.cast::<CalcResolveContext>() };

1561

        crate::solver3::calc::evaluate_calc(ctx, basis)

1562

1563

1564

1787936

    fn compute_child_layout(

1565

1787936

        &mut self,

1566

1787936

        node_id: taffy::NodeId,

1567

1787936

        inputs: LayoutInput,

1568

1787936

    ) -> LayoutOutput {

1569

1787936

        let node_idx: usize = node_id.into();

1570

1571

        // DEBUG: Log the style being used for this child

1572

1787936

        if self.ctx.debug_messages.is_some() {

1573

1787670

            let style = self.get_taffy_style(node_idx);

1574

1787670

            self.ctx.debug_info_inner(format!(

1575

1787670

                "[TAFFY compute_child_layout] node_idx={} flex_grow={} flex_shrink={} \

1576

1787670

                 flex_basis={:?} size=({:?}, {:?}) inputs.known_dims=({:?}, {:?})",

1577

1787670

                node_idx,

1578

1787670

                style.flex_grow,

1579

1787670

                style.flex_shrink,

1580

1787670

                style.flex_basis,

1581

1787670

                style.size.width,

1582

1787670

                style.size.height,

1583

1787670

                inputs.known_dimensions.width,

1584

1787670

                inputs.known_dimensions.height

1585

1787670

));

1586

1787670

1587

1588

        // Get formatting context

1589

1787936

        let fc = self

1590

1787936

            .tree

1591

1787936

            .get(LayoutNodeId::new(node_idx))

1592

1787936

            .map(|s| s.formatting_context)

1593

1787936

            .unwrap_or_default();

1594

1595

        // PURE CONTENT MEASURE cache (min-/max-content, no known dimensions).

1596

        // These answers are viewport-independent, but taffy's own cache

1597

        // cannot keep them alive: the flex algorithm's candidate-width

1598

        // probes share their slot class and evict them within every pass.

1599

        // Serve them from the warm node instead — invalidated with

1600

        // `taffy_cache` by the intrinsic-dirty ancestor closure. Gated off

1601

        // for documents that use viewport units (vw/vh in font sizes make

1602

        // "content size" viewport-dependent), mirroring the collect gate.

1603

1787936

        let pure_measure_slot = if inputs.run_mode == RunMode::ComputeSize

1604

1678486

            && inputs.known_dimensions.width.is_none()

1605

1182174

            && inputs.known_dimensions.height.is_none()

1606

842601

            && !self

1607

842601

                .ctx

1608

842601

                .styled_dom

1609

842601

                .css_property_cache

1610

842601

                .ptr

1611

842601

                .compact_cache

1612

842601

                .as_ref()

1613

842601

                .is_none_or(|cc| cc.uses_viewport_units)

1614

1615

842601

            match inputs.available_space.width {

1616

446334

                AvailableSpace::MinContent => Some(0usize),

1617

323979

                AvailableSpace::MaxContent => Some(1usize),

1618

72288

                AvailableSpace::Definite(_) => None,

1619

1620

        } else {

1621

945335

            None

1622

};

1623

1787936

        if let Some(slot) = pure_measure_slot {

1624

770313

            if let Some(warm) = self.tree.warm(LayoutNodeId::new(node_idx)) {

1625

770313

                let cached = match slot {

1626

446334

                    0 => warm.measured_content_sizes.0,

1627

323979

                    _ => warm.measured_content_sizes.1,

1628

};

1629

770313

                if let Some(out) = cached {

1630

639081

                    drop(crate::probe::Probe::span("taffy_pure_measure_hit"));

1631

639081

                    return out;

1632

131232

1633

1634

131232

            drop(crate::probe::Probe::span("taffy_pure_measure_miss"));

1635

1017623

1636

1637

1148855

        let mut result = compute_cached_layout(self, node_id, inputs, |tree, node_id, inputs| {

1638

627294

            let node_idx: usize = node_id.into();

1639

627294

            let fc = tree

1640

627294

                .tree

1641

627294

                .get(LayoutNodeId::new(node_idx))

1642

627294

                .map(|s| s.formatting_context)

1643

627294

                .unwrap_or_default();

1644

1645

627294

            match fc {

1646

360506

                FormattingContext::Flex => compute_flexbox_layout(tree, node_id, inputs),

1647

                FormattingContext::Grid => compute_grid_layout(tree, node_id, inputs),

1648

                // For Block, Inline, Table, InlineBlock - delegate to layout_formatting_context

1649

                // This ensures proper recursive layout of all formatting contexts

1650

266788

                _ => tree.compute_non_flex_layout(node_idx, inputs),

1651

1652

627294

});

1653

1654

        // Populate the pure-measure cache from the result we just computed.

1655

1148855

        if let Some(slot) = pure_measure_slot {

1656

131232

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

1657

131232

                match slot {

1658

65814

                    0 => warm.measured_content_sizes.0 = Some(result),

1659

65418

                    _ => warm.measured_content_sizes.1 = Some(result),

1660

1661

1662

1017623

1663

1664

        // Store layout for container nodes - Taffy only calls set_unrounded_layout for leaf nodes

1665

1148855

        if let Some(node) = self.tree.get_mut(LayoutNodeId::new(node_idx)) {

1666

1148855

            let size = translate_taffy_size_back(result.size);

1667

1148855

            node.used_size = Some(size);

1668

1148855

1669

1670

        // CRITICAL FIX: For Flex/Grid children with overflow:auto/scroll,

1671

        // compute scrollbar_info by comparing Taffy's content_size against the

1672

        // CSS-specified container size.

1673

//

1674

        // We skip when content_size is (0,0) because that's the sizing pass

1675

        // where Taffy hasn't determined actual content size yet. The final

1676

        // layout pass always has non-zero content_size for nodes that need

1677

        // scroll. This avoids 2/3 of the compute_taffy_scrollbar_info calls

1678

        // (one sizing pass per axis) while still getting correct final values.

1679

1148855

        if matches!(fc, FormattingContext::Flex | FormattingContext::Grid) {

1680

597512

            let taffy_content_width = result.content_size.width;

1681

597512

            let taffy_content_height = result.content_size.height;

1682

1683

            // Skip on sizing pass where content_size is still zero:

1684

            // scrollbar_info computed from zero content would be wrong anyway.

1685

597512

            if taffy_content_width <= 0.0 && taffy_content_height <= 0.0 {

1686

545835

                return result;

1687

51677

1688

1689

51677

            let (scrollbar_info, eff_content_w, eff_content_h) =

1690

51677

                compute_taffy_scrollbar_info(

1691

51677

                    self.ctx,

1692

51677

                    self.tree,

1693

51677

                    node_idx,

1694

51677

                    result.size.width,

1695

51677

                    result.size.height,

1696

51677

                    taffy_content_width,

1697

51677

                    taffy_content_height,

1698

51677

                    ContentSizeOrigin::BorderBox,

1699

51677

);

1700

1701

51677

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

1702

51677

                warm.scrollbar_info = Some(scrollbar_info);

1703

51677

                // eff_content_w/h are already in content-box coordinates

1704

51677

                // (the border+padding inset is subtracted in

1705

51677

                // compute_taffy_scrollbar_info), so store directly without

1706

51677

                // further subtraction.

1707

51677

                warm.overflow_content_size = Some(LogicalSize::new(

1708

51677

                    eff_content_w,

1709

51677

                    eff_content_h,

1710

51677

));

1711

51677

1712

551343

1713

1714

603020

        result

1715

1787936

1716

1717

1718

impl<T: ParsedFontTrait> TaffyBridge<'_, '_, T> {

1719

    /// Compute layout for non-flex/grid nodes by delegating to `layout_formatting_context`.

1720

    /// This handles Block, Inline, Table, `InlineBlock` formatting contexts recursively.

1721

    #[allow(clippy::match_same_arms)] // enum/value mapping/dispatch table: one arm per input variant (or cross-type bindings that can't merge)

1722

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

1723

266788

    fn compute_non_flex_layout(&mut self, node_idx: usize, inputs: LayoutInput) -> LayoutOutput {

1724

        // Taffy's known_dimensions are BORDER-BOX sizes (the child's outer size

1725

        // as determined by the parent flex/grid algorithm, e.g. via stretch alignment).

1726

        // Our BFC/IFC layout expects the available_size to be the CONTENT-BOX width

1727

        // (i.e. the space available for the child's own content, excluding the child's

1728

        // own padding and border).

1729

//

1730

        // Get padding/border early so we can convert border-box → content-box.

1731

266788

        let (node_padding_width, node_padding_height, node_border_width, node_border_height) = self

1732

266788

            .tree

1733

266788

            .get(LayoutNodeId::new(node_idx))

1734

266788

            .map_or((0.0, 0.0, 0.0, 0.0), |node| {

1735

266788

                let bp = node.box_props.unpack();

1736

266788

1737

266788

                    bp.padding.left + bp.padding.right,

1738

266788

                    bp.padding.top + bp.padding.bottom,

1739

266788

                    bp.border.left + bp.border.right,

1740

266788

                    bp.border.top + bp.border.bottom,

1741

266788

1742

266788

});

1743

1744

        // Determine available size from Taffy's inputs.

1745

        // When known_dimensions is set (e.g. flex stretch), subtract the child's own

1746

        // padding+border to convert from border-box to content-box available space.

1747

        // For MinContent/MaxContent, use INFINITY and let the text layout calculate

1748

        // its actual intrinsic width.

1749

266788

        let available_width = inputs

1750

266788

            .known_dimensions

1751

266788

            .width

1752

266788

            .map(|kw| (kw - node_padding_width - node_border_width).max(0.0))

1753

266788

            .or(match inputs.available_space.width {

1754

165142

                AvailableSpace::Definite(w) => Some(w),

1755

56223

                AvailableSpace::MinContent => None, // Use infinity, return intrinsic min-content

1756

45423

                AvailableSpace::MaxContent => None, // Use infinity for max-content

1757

})

1758

266788

            .unwrap_or(f32::INFINITY);

1759

1760

266788

        let available_height = inputs

1761

266788

            .known_dimensions

1762

266788

            .height

1763

266788

            .map(|kh| (kh - node_padding_height - node_border_height).max(0.0))

1764

266788

            .or(match inputs.available_space.height {

1765

143685

                AvailableSpace::Definite(h) => Some(h),

1766

85462

                AvailableSpace::MinContent => None, // Use infinity, return intrinsic min-content

1767

37641

                AvailableSpace::MaxContent => None,

1768

})

1769

266788

            .unwrap_or(f32::INFINITY);

1770

1771

266788

        let mut available_size = LogicalSize {

1772

266788

            width: available_width,

1773

266788

            height: available_height,

1774

266788

};

1775

1776

        // NOTE: Scrollbar reservation is handled inside layout_bfc() where it subtracts

1777

        // scrollbar width from children_containing_block_size. We do NOT subtract here

1778

        // to avoid double-subtraction when compute_non_flex_layout delegates to

1779

        // layout_formatting_context → layout_bfc.

1780

1781

        // Convert Taffy's AvailableSpace to our Text3AvailableSpace for caching.

1782

        // When the child has known_dimensions.width (from flex/grid layout), use that

1783

        // instead of the parent's available_space — otherwise text centers/wraps in

1784

        // the wrong width (e.g., 404px parent instead of 120px child).

1785

266788

        let available_width_type = if inputs.known_dimensions.width.is_some() {

1786

138679

            crate::text3::cache::AvailableSpace::Definite(available_width)

1787

        } else {

1788

128109

            match inputs.available_space.width {

1789

26463

                AvailableSpace::Definite(w) => crate::text3::cache::AvailableSpace::Definite(w),

1790

56223

                AvailableSpace::MinContent => crate::text3::cache::AvailableSpace::MinContent,

1791

45423

                AvailableSpace::MaxContent => crate::text3::cache::AvailableSpace::MaxContent,

1792

1793

};

1794

1795

        // Get text-align from CSS for this node (important for centering content in flex items)

1796

266788

        let text_align = self

1797

266788

            .tree

1798

266788

            .get(LayoutNodeId::new(node_idx))

1799

266788

            .and_then(|node| node.dom_node_id)

1800

266788

            .map(|dom_id| {

1801

266788

                let node_state =

1802

266788

                    &self.ctx.styled_dom.styled_nodes.as_container()[dom_id].styled_node_state;

1803

266788

                crate::solver3::getters::get_text_align(self.ctx.styled_dom, dom_id, node_state)

1804

266788

                    .unwrap_or_default()

1805

266788

})

1806

266788

            .unwrap_or_default();

1807

1808

        // Convert CSS text-align to our internal TextAlign enum

1809

266788

        let fc_text_align = match text_align {

1810

            azul_css::props::style::StyleTextAlign::Left => FcTextAlign::Start,

1811

            azul_css::props::style::StyleTextAlign::Right => FcTextAlign::End,

1812

38727

            azul_css::props::style::StyleTextAlign::Center => FcTextAlign::Center,

1813

            azul_css::props::style::StyleTextAlign::Justify => FcTextAlign::Justify,

1814

228061

            azul_css::props::style::StyleTextAlign::Start => FcTextAlign::Start,

1815

            azul_css::props::style::StyleTextAlign::End => FcTextAlign::End,

1816

};

1817

1818

        // SAFETY: `self.text_cache` was derived from `&mut TextLayoutCache` in

1819

        // `layout_taffy_subtree` and no other reference to it exists at this point.

1820

        // The raw pointer is necessary because we already hold `&mut self` (which

1821

        // borrows `ctx` and `tree`), and Rust's borrow checker cannot express the

1822

        // disjointness of text_cache from ctx/tree.

1823

266788

        let text_cache = unsafe { &mut *self.text_cache };

1824

1825

266788

        let constraints = LayoutConstraints {

1826

266788

            available_size,

1827

266788

            writing_mode: LayoutWritingMode::HorizontalTb,

1828

266788

            writing_mode_ctx: super::geometry::WritingModeContext::default(),

1829

266788

            bfc_state: None,

1830

266788

            text_align: fc_text_align,

1831

266788

            containing_block_size: available_size,

1832

266788

            available_width_type,

1833

266788

            fragmentainer: None,

1834

266788

};

1835

1836

        // A prior Taffy measurement pass (e.g. the min-content pass Taffy runs to

1837

        // find a flex item's intrinsic width) stores its result in `node.used_size`

1838

        // at the end of this function. layout_bfc then reads `used_size` as the

1839

        // children's containing-block width. When the subsequent definite-width

1840

        // cross-sizing pass re-enters here, that STALE min-content width (not this

1841

        // pass's `known_dimensions.width`) drives child wrapping — so a flex item

1842

        // with long text wraps at min-content and reports an over-tall cross size,

1843

        // over-sizing the container (invoice `.head` measured 125px for ~45px of

1844

        // content). Reset `used_size` to the border-box dims Taffy fixed for THIS

1845

        // measure. When width is unknown (an intrinsic pass), clear it so layout_bfc

1846

        // falls back to `constraints.available_size` (INFINITY → true intrinsic).

1847

266788

        if let Some(n) = self.tree.get_mut(LayoutNodeId::new(node_idx)) {

1848

266788

            n.used_size = match (inputs.known_dimensions.width, inputs.known_dimensions.height) {

1849

54155

                (Some(w), Some(h)) => Some(LogicalSize {

1850

54155

                    width: w,

1851

54155

                    height: h,

1852

54155

}),

1853

84524

                (Some(w), None) if available_height.is_finite() => Some(LogicalSize {

1854

61249

                    width: w,

1855

61249

                    height: available_height + node_padding_height + node_border_height,

1856

61249

}),

1857

                // Height genuinely unknown with INFINITE available height —

1858

                // the main-axis content-measure pass of a COLUMN flex

1859

                // container (cross width is known via stretch, height is

1860

                // what taffy is asking us to compute). The old arm

1861

                // fabricated height 0.0 here, and layout_bfc then used that

1862

                // used_size as the children's containing block: every

1863

                // descendant laid out inside a 0-HEIGHT box, the results

1864

                // were cached, and auto-height text content inside a

1865

                // fixed-height column flex item rendered as NOTHING (row

1866

                // containers dodged it because the UNKNOWN axis there is

1867

                // the width, which maps to None). Clear instead — layout_bfc

1868

                // falls back to constraints.available_size (the true

1869

                // content-measure request), same as the width-unknown case.

1870

151384

                _ => None,

1871

};

1872

1873

1874

        // Use a temporary float cache for this subtree

1875

266788

        let mut float_cache = HashMap::new();

1876

1877

        // Call layout_formatting_context - this handles ALL formatting context types

1878

        // including nested flex/grid, tables, BFC, and IFC

1879

266788

        let fc_result = crate::solver3::fc::layout_formatting_context(

1880

266788

            self.ctx,

1881

266788

            self.tree,

1882

266788

            text_cache,

1883

266788

            node_idx,

1884

266788

            &constraints,

1885

266788

            &mut float_cache,

1886

);

1887

1888

266788

        match fc_result {

1889

266788

            Ok(bfc_result) => {

1890

266788

                let output = bfc_result.output;

1891

266788

                let content_width = output.overflow_size.width;

1892

266788

                let content_height = output.overflow_size.height;

1893

1894

                // Padding/border already computed at start of function

1895

266788

                let padding_width = node_padding_width;

1896

266788

                let padding_height = node_padding_height;

1897

266788

                let border_width = node_border_width;

1898

266788

                let border_height = node_border_height;

1899

1900

                // Get intrinsic sizes for min/max-content queries

1901

266788

                let intrinsic = self

1902

266788

                    .tree

1903

266788

                    .warm(LayoutNodeId::new(node_idx))

1904

266788

                    .and_then(|w| w.intrinsic_sizes)

1905

266788

                    .unwrap_or_default();

1906

1907

                // min-content size in the main axis; for items with a preferred aspect ratio, it

1908

                // should be clamped by definite min/max cross sizes converted through the ratio.

1909

                // For MinContent/MaxContent queries, use intrinsic sizes instead of layout result.

1910

                // HOWEVER: If intrinsic sizes are 0 but content_width is non-zero, use content_width.

1911

                // This happens for FormattingContext::Inline nodes that are measured by their

1912

                // parent IFC root and don't have their own intrinsic sizes stored.

1913

//

1914

                // CRITICAL FIX: For InlineBlock elements with width: auto (known_dimensions.width = None),

1915

                // we must use intrinsic max-content width instead of content_width from BFC layout.

1916

                // The BFC layout was done with the full container width, but InlineBlock should

1917

                // shrink-to-fit its content. This is per CSS 2.1 § 10.3.9: "shrink-to-fit width".

1918

266788

                let fc = self

1919

266788

                    .tree

1920

266788

                    .get(LayoutNodeId::new(node_idx))

1921

266788

                    .map(|s| s.formatting_context)

1922

266788

                    .unwrap_or_default();

1923

1924

266788

                let is_shrink_to_fit = matches!(fc, FormattingContext::InlineBlock)

1925

                    && inputs.known_dimensions.width.is_none();

1926

1927

266788

                let effective_content_width = match inputs.available_space.width {

1928

                    AvailableSpace::MinContent => {

1929

56223

                        if intrinsic.min_content_width > 0.0 {

1930

39024

                            intrinsic.min_content_width

1931

                        } else {

1932

17199

                            content_width

1933

1934

1935

                    AvailableSpace::MaxContent => {

1936

45423

                        if intrinsic.max_content_width > 0.0 {

1937

28260

                            intrinsic.max_content_width

1938

                        } else {

1939

17163

                            content_width

1940

1941

1942

                    AvailableSpace::Definite(_) => {

1943

                        // For shrink-to-fit elements (InlineBlock with auto width),

1944

                        // use intrinsic max-content width clamped by available space.

1945

                        // CSS 2.1 § 10.3.9: shrink-to-fit = min(max(preferred minimum, available), preferred)

1946

165142

                        if is_shrink_to_fit && intrinsic.max_content_width > 0.0 {

1947

                            // Use max-content (preferred width) - already clamped by min/max-width in sizing

1948

                            intrinsic.max_content_width

1949

                        } else {

1950

165142

                            content_width

1951

1952

1953

};

1954

1955

                // Replaced elements (image / VirtualView) have NO flow content, so the

1956

                // BFC content_height above is 0 (and shrink-to-fit width may be wrong).

1957

                // Their content size is the CSS/intrinsic-resolved size from

1958

                // calculate_used_size_for_node (border-box) — strip padding+border back

1959

                // to content-box. Fixes blank / 0-height images as flex/grid items.

1960

266788

                let (effective_content_width, content_height) = {

1961

266788

                    let dom_id = self.tree.get(LayoutNodeId::new(node_idx)).and_then(|n| n.dom_node_id);

1962

266788

                    let is_replaced = dom_id

1963

266788

                        .is_some_and(|id| {

1964

266788

                            let nd = &self.ctx.styled_dom.node_data.as_container()[id];

1965

266788

                            matches!(nd.get_node_type(), azul_core::dom::NodeType::Image(_))

1966

266712

                                || nd.is_virtual_view_node()

1967

266788

});

1968

266788

                    match (is_replaced, dom_id) {

1969

76

                        (true, Some(id)) => {

1970

76

                            let bp = self.tree.get(LayoutNodeId::new(node_idx)).unwrap().box_props.unpack();

1971

76

                            crate::solver3::sizing::calculate_used_size_for_node(

1972

76

                                self.ctx.styled_dom,

1973

76

                                Some(id),

1974

76

                                &constraints.containing_block_size,

1975

76

                                intrinsic,

1976

76

                                &bp,

1977

76

                                &self.ctx.viewport_size,

1978

76

                            ).map_or((effective_content_width, content_height), |sz| (

1979

76

                                    (sz.width - padding_width - border_width).max(0.0),

1980

76

                                    (sz.height - padding_height - border_height).max(0.0),

1981

))

1982

1983

266712

                        _ => (effective_content_width, content_height),

1984

1985

};

1986

1987

                // Convert content-box size to border-box size (for when we compute our own size)

1988

266788

                let border_box_width = effective_content_width + padding_width + border_width;

1989

266788

                let border_box_height = content_height + padding_height + border_height;

1990

1991

                // CRITICAL: Taffy's known_dimensions is BORDER-BOX (the child's

1992

                // outer size as set by the parent flex/grid algorithm). Our BFC/IFC

1993

                // layout computes content-box sizes, but Taffy expects the returned

1994

                // `size` to be BORDER-BOX for correct positioning of subsequent items.

1995

//

1996

                // When known_dimensions is set: use it directly (it's already border-box).

1997

                // When it's None: add padding+border to our content-box result.

1998

266788

                let final_width = inputs.known_dimensions.width.map_or(border_box_width, |border_box_w| border_box_w);

1999

2000

                // For grid items: if known_dimensions.height is None but available_space.height

2001

                // is definite, use the available space. This ensures empty grid items stretch

2002

                // to fill their grid cell, per CSS Grid spec behavior.

2003

266788

                let final_height = if let Some(border_box_h) = inputs.known_dimensions.height { border_box_h } else {

2004

                    // Check if parent is a grid container and available_space is definite

2005

203840

                    let parent_is_grid = self

2006

203840

                        .tree

2007

203840

                        .get(LayoutNodeId::new(node_idx))

2008

203840

                        .and_then(|n| n.parent)

2009

203840

                        .and_then(|p| self.tree.get(LayoutNodeId::new(p)))

2010

203840

                        .is_some_and(|p| matches!(p.formatting_context, FormattingContext::Grid));

2011

2012

203840

                    if parent_is_grid {

2013

                        // For grid items, use available space if content is smaller

2014

288

                        match inputs.available_space.height {

2015

                            AvailableSpace::Definite(h) => {

2016

                                // Grid items stretch to fill their cell by default

2017

                                // Use the larger of content size or available space

2018

                                h.max(border_box_height)

2019

2020

288

                            _ => border_box_height,

2021

2022

                    } else {

2023

203552

                        border_box_height

2024

2025

};

2026

2027

                // CRITICAL: Transfer positions from layout_formatting_context to child nodes.

2028

                // Without this, children of flex items won't have their relative_position set,

2029

                // causing them to all render at (0,0) relative to their parent.

2030

267605

                for (child_idx, child_pos) in &output.positions {

2031

817

                    if let Some(child_warm) = self.tree.warm_mut(LayoutNodeId::new(*child_idx)) {

2032

817

                        child_warm.relative_position = Some(*child_pos);

2033

817

2034

2035

2036

                // Compute scrollbar_info for this node (it's a child of a Flex/Grid container,

2037

                // so calculate_layout_for_subtree won't be called for it).

2038

                // Uses the unified compute_scrollbar_info_core path.

2039

//

2040

                // content_width/height come from our own BFC/IFC overflow_size,

2041

                // which is already content-box relative — unlike Taffy's

2042

                // border-box-origin content_size.

2043

266788

                let (scrollbar_info, _, _) = compute_taffy_scrollbar_info(

2044

266788

                    self.ctx,

2045

266788

                    self.tree,

2046

266788

                    node_idx,

2047

266788

                    final_width,

2048

266788

                    final_height,

2049

266788

                    content_width,

2050

266788

                    content_height,

2051

266788

                    ContentSizeOrigin::ContentBox,

2052

266788

);

2053

2054

                // Store the border-box size and scrollbar_info on the node for display list generation

2055

266788

                if let Some(node) = self.tree.get_mut(LayoutNodeId::new(node_idx)) {

2056

266788

                    node.used_size = Some(LogicalSize {

2057

266788

                        width: final_width,

2058

266788

                        height: final_height,

2059

266788

});

2060

266788

2061

266788

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

2062

266788

                    warm.scrollbar_info = Some(scrollbar_info);

2063

266788

                    // Store the actual content size for scroll calculations

2064

266788

                    warm.overflow_content_size = Some(LogicalSize {

2065

266788

                        width: content_width,

2066

266788

                        height: content_height,

2067

266788

});

2068

266788

2069

2070

                // Return the same size to Taffy for correct positioning

2071

266788

                LayoutOutput {

2072

266788

                    size: Size {

2073

266788

                        width: final_width,

2074

266788

                        height: final_height,

2075

266788

},

2076

266788

                    content_size: Size {

2077

266788

                        width: content_width,

2078

266788

                        height: content_height,

2079

266788

},

2080

266788

                    first_baselines: taffy::Point {

2081

266788

                        x: None,

2082

266788

                        y: output.baseline,

2083

266788

},

2084

266788

                    top_margin: taffy::CollapsibleMarginSet::ZERO,

2085

266788

                    bottom_margin: taffy::CollapsibleMarginSet::ZERO,

2086

266788

                    margins_can_collapse_through: false,

2087

266788

2088

2089

            Err(_e) => {

2090

                // Fallback to intrinsic sizes if layout fails

2091

                let intrinsic = self.tree.warm(LayoutNodeId::new(node_idx)).and_then(|w| w.intrinsic_sizes).unwrap_or_default();

2092

2093

                let width = inputs

2094

                    .known_dimensions

2095

                    .width

2096

                    .unwrap_or(intrinsic.max_content_width);

2097

                let height = inputs

2098

                    .known_dimensions

2099

                    .height

2100

                    .unwrap_or(intrinsic.max_content_height);

2101

2102

                LayoutOutput {

2103

                    size: Size { width, height },

2104

                    content_size: Size { width, height },

2105

                    first_baselines: taffy::Point { x: None, y: None },

2106

                    top_margin: taffy::CollapsibleMarginSet::ZERO,

2107

                    bottom_margin: taffy::CollapsibleMarginSet::ZERO,

2108

                    margins_can_collapse_through: false,

2109

2110

2111

2112

266788

2113

2114

2115

impl<T: ParsedFontTrait> CacheTree for TaffyBridge<'_, '_, T> {

2116

1148855

    fn cache_get(

2117

1148855

        &self,

2118

1148855

        node_id: taffy::NodeId,

2119

1148855

        input: &LayoutInput,

2120

1148855

    ) -> Option<LayoutOutput> {

2121

1148855

        let node_idx: usize = node_id.into();

2122

1148855

        let hit = self.tree

2123

1148855

            .warm(LayoutNodeId::new(node_idx))?

2124

            .taffy_cache

2125

1148855

            .get(input);

2126

1148855

        drop(crate::probe::Probe::span(if hit.is_some() {

2127

521561

            "taffy_cache_get_hit"

2128

        } else {

2129

627294

            "taffy_cache_get_miss"

2130

        }));

2131

        // AZ_TAFFY_DEBUG: one line per lookup with the full taffy cache key.

2132

        // Diffing two passes' lines for the same node names WHICH component

2133

        // (known_dimensions / available_space / run_mode) moved and broke

2134

        // the key — aggregates can't tell that.

2135

1148855

        if std::env::var_os("AZ_TAFFY_DEBUG").is_some() {

2136

            eprintln!(

2137

                "[taffy] {} n{} kd=({:?},{:?}) avail=({:?},{:?}) mode={:?}",

2138

                if hit.is_some() { "HIT " } else { "MISS" },

2139

                node_idx,

2140

                input.known_dimensions.width,

2141

                input.known_dimensions.height,

2142

                input.available_space.width,

2143

                input.available_space.height,

2144

                input.run_mode,

2145

);

2146

1148855

2147

1148855

hit

2148

1148855

2149

2150

627294

    fn cache_store(

2151

627294

        &mut self,

2152

627294

        node_id: taffy::NodeId,

2153

627294

        input: &LayoutInput,

2154

627294

        layout_output: LayoutOutput,

2155

627294

) {

2156

627294

        let node_idx: usize = node_id.into();

2157

627294

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

2158

627294

            warm.taffy_cache

2159

627294

                .store(input, layout_output);

2160

627294

2161

627294

2162

2163

    fn cache_clear(&mut self, node_id: taffy::NodeId) {

2164

        drop(crate::probe::Probe::span("taffy_cache_clear"));

2165

        let node_idx: usize = node_id.into();

2166

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

2167

            warm.taffy_cache.clear();

2168

            warm.measured_content_sizes = (None, None);

2169

2170

2171

2172

2173

impl<T: ParsedFontTrait> LayoutFlexboxContainer for TaffyBridge<'_, '_, T> {

2174

    type FlexboxContainerStyle<'c>

2175

        = Style

2176

    where

2177

        Self: 'c;

2178

    type FlexboxItemStyle<'c>

2179

        = Style

2180

    where

2181

        Self: 'c;

2182

2183

934026

    fn get_flexbox_container_style(

2184

934026

        &self,

2185

934026

        node_id: taffy::NodeId,

2186

934026

    ) -> Self::FlexboxContainerStyle<'_> {

2187

934026

        self.get_core_container_style(node_id)

2188

934026

2189

2190

2055692

    fn get_flexbox_child_style(&self, child_node_id: taffy::NodeId) -> Self::FlexboxItemStyle<'_> {

2191

2055692

        self.get_core_container_style(child_node_id)

2192

2055692

2193

2194

2195

impl<T: ParsedFontTrait> LayoutGridContainer for TaffyBridge<'_, '_, T> {

2196

    type GridContainerStyle<'c>

2197

        = Style

2198

    where

2199

        Self: 'c;

2200

    type GridItemStyle<'c>

2201

        = Style

2202

    where

2203

        Self: 'c;

2204

2205

27

    fn get_grid_container_style(&self, node_id: taffy::NodeId) -> Self::GridContainerStyle<'_> {

2206

27

        self.get_core_container_style(node_id)

2207

27

2208

2209

594

    fn get_grid_child_style(&self, child_node_id: taffy::NodeId) -> Self::GridItemStyle<'_> {

2210

594

        self.get_core_container_style(child_node_id)

2211

594

2212

2213

2214

// --- Conversion Functions ---

2215

2216

#[allow(clippy::match_same_arms)] // enum/value mapping/dispatch table: one arm per input variant (or cross-type bindings that can't merge)

2217

#[allow(clippy::vec_box)] // calc_storage Box gives stable addresses for taffy calc() pointers

2218

111692

fn from_layout_width(

2219

111692

    val: LayoutWidth,

2220

111692

    calc_storage: &std::cell::RefCell<Vec<Box<CalcResolveContext>>>,

2221

111692

    em_size: f32,

2222

111692

    rem_size: f32,

2223

111692

) -> Dimension {

2224

111692

    match val {

2225

100425

        LayoutWidth::Auto => Dimension::auto(),

2226

11260

        LayoutWidth::Px(px) => pixel_value_to_pixels_fallback(&px).map_or_else(

2227

215

            || px.to_percent().map_or_else(Dimension::auto, |p| Dimension::percent(p.get())),

2228

            Dimension::length,

2229

),

2230

6

        LayoutWidth::MinContent | LayoutWidth::MaxContent | LayoutWidth::FitContent(_) => Dimension::auto(),

2231

1

        LayoutWidth::Calc(items) => store_calc_and_make_dimension(items, calc_storage, em_size, rem_size),

2232

2233

111692

2234

2235

#[allow(clippy::match_same_arms)] // enum/value mapping/dispatch table: one arm per input variant (or cross-type bindings that can't merge)

2236

#[allow(clippy::vec_box)] // calc_storage Box gives stable addresses for taffy calc() pointers

2237

111683

fn from_layout_height(

2238

111683

    val: LayoutHeight,

2239

111683

    calc_storage: &std::cell::RefCell<Vec<Box<CalcResolveContext>>>,

2240

111683

    em_size: f32,

2241

111683

    rem_size: f32,

2242

111683

) -> Dimension {

2243

111683

    match val {

2244

85362

        LayoutHeight::Auto => Dimension::auto(),

2245

26318

        LayoutHeight::Px(px) => pixel_value_to_pixels_fallback(&px).map_or_else(

2246

287

            || px.to_percent().map_or_else(Dimension::auto, |p| Dimension::percent(p.get())),

2247

            Dimension::length,

2248

),

2249

3

        LayoutHeight::MinContent | LayoutHeight::MaxContent | LayoutHeight::FitContent(_) => Dimension::auto(),

2250

        LayoutHeight::Calc(items) => store_calc_and_make_dimension(items, calc_storage, em_size, rem_size),

2251

2252

111683

2253

2254

/// Stores the calc AST + font-size context in heap-pinned storage and returns

2255

/// a `Dimension::calc(ptr)` with a stable pointer to the `CalcResolveContext`.

2256

///

2257

/// The `Box` ensures the address doesn't move when the outer `Vec` reallocates.

2258

/// The `RefCell<Vec<…>>` keeps all boxes alive for the layout pass duration.

2259

#[allow(clippy::vec_box)] // calc_storage Box gives stable addresses for taffy calc() pointers

2260

260

fn store_calc_and_make_dimension(

2261

260

    items: CalcAstItemVec,

2262

260

    storage: &std::cell::RefCell<Vec<Box<CalcResolveContext>>>,

2263

260

    em_size: f32,

2264

260

    rem_size: f32,

2265

260

) -> Dimension {

2266

260

    let boxed = Box::new(CalcResolveContext { items, em_size, rem_size });

2267

260

    let ptr: *const CalcResolveContext = &raw const *boxed;

2268

260

    storage.borrow_mut().push(boxed);

2269

    // SAFETY: Box gives ≥8-byte-aligned heap pointer; taffy masks low 3 bits.

2270

260

    Dimension::calc(ptr.cast::<()>())

2271

260

2272

2273

#[allow(clippy::match_same_arms)] // enum/value mapping/dispatch table: one arm per input variant (or cross-type bindings that can't merge)

2274

111685

const fn from_layout_position(val: LayoutPosition) -> Position {

2275

111685

    match val {

2276

110345

        LayoutPosition::Static => Position::Relative, // Taffy treats Static as Relative

2277

1325

        LayoutPosition::Relative => Position::Relative,

2278

11

        LayoutPosition::Absolute => Position::Absolute,

2279

2

        LayoutPosition::Fixed => Position::Absolute, // Taffy doesn't distinguish Fixed

2280

2

        LayoutPosition::Sticky => Position::Relative, // Sticky = Relative for Taffy

2281

2282

111685

2283

2284

#[cfg(test)]

2285

#[allow(

2286

    clippy::float_cmp,

2287

    clippy::too_many_lines,

2288

    clippy::cast_precision_loss,

2289

    clippy::cast_possible_truncation

2290

)]

2291

mod autotest_generated {

2292

    use azul_css::props::layout::{

2293

        dimensions::CalcAstItem,

2294

        grid::{

2295

            GridLine as AzGridLine, GridMinMax, GridPlacement as AzGridPlacement,

2296

            GridTrackSizingVec, LayoutJustifyItems, NamedGridLine,

2297

},

2298

        LayoutOverflow,

2299

};

2300

2301

    use super::*;

2302

2303

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

2304

    // Fixtures

2305

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

2306

2307

    fn track_vec(v: Vec<GridTrackSizing>) -> GridTrackSizingVec {

2308

        GridTrackSizingVec::from_vec(v)

2309

2310

2311

    fn template(v: Vec<GridTrackSizing>) -> GridTemplate {

2312

        GridTemplate { tracks: track_vec(v) }

2313

2314

2315

    fn auto_tracks(v: Vec<GridTrackSizing>) -> GridAutoTracks {

2316

        GridAutoTracks { tracks: track_vec(v) }

2317

2318

2319

    /// The absolute metrics `pixel_value_to_pixels_fallback` can resolve.

2320

    const ABSOLUTE_METRICS: [SizeMetric; 7] = [

2321

        SizeMetric::Px,

2322

        SizeMetric::Pt,

2323

        SizeMetric::In,

2324

        SizeMetric::Cm,

2325

        SizeMetric::Mm,

2326

        SizeMetric::Em,

2327

        SizeMetric::Rem,

2328

];

2329

2330

    /// The metrics that need a resolution context this function does not have.

2331

    const CONTEXTUAL_METRICS: [SizeMetric; 5] = [

2332

        SizeMetric::Percent,

2333

        SizeMetric::Vw,

2334

        SizeMetric::Vh,

2335

        SizeMetric::Vmin,

2336

        SizeMetric::Vmax,

2337

];

2338

2339

    fn approx(actual: f32, expected: f32) {

2340

        assert!(

2341

            (actual - expected).abs() < 1e-3,

2342

            "expected ~{expected}, got {actual}"

2343

);

2344

2345

2346

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

2347

    // pixel_value_to_pixels_fallback — numeric

2348

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

2349

2350

    #[test]

2351

    fn pixel_value_to_pixels_fallback_is_zero_at_zero_for_every_absolute_metric() {

2352

        for m in ABSOLUTE_METRICS {

2353

            assert_eq!(

2354

                pixel_value_to_pixels_fallback(&PixelValue::from_metric(m, 0.0)),

2355

                Some(0.0),

2356

                "{m:?}"

2357

);

2358

2359

2360

2361

    #[test]

2362

    fn pixel_value_to_pixels_fallback_converts_each_absolute_unit_to_css_px() {

2363

        assert_eq!(

2364

            pixel_value_to_pixels_fallback(&PixelValue::px(10.5)),

2365

            Some(10.5)

2366

);

2367

        assert_eq!(

2368

            pixel_value_to_pixels_fallback(&PixelValue::inch(1.0)),

2369

            Some(96.0)

2370

);

2371

        assert_eq!(

2372

            pixel_value_to_pixels_fallback(&PixelValue::em(2.0)),

2373

            Some(2.0 * DEFAULT_FONT_SIZE)

2374

);

2375

        assert_eq!(

2376

            pixel_value_to_pixels_fallback(&PixelValue::rem(2.0)),

2377

            Some(2.0 * DEFAULT_FONT_SIZE)

2378

);

2379

        approx(

2380

            pixel_value_to_pixels_fallback(&PixelValue::pt(72.0)).unwrap(),

2381

            96.0,

2382

);

2383

        approx(

2384

            pixel_value_to_pixels_fallback(&PixelValue::cm(2.54)).unwrap(),

2385

            96.0,

2386

);

2387

        approx(

2388

            pixel_value_to_pixels_fallback(&PixelValue::mm(25.4)).unwrap(),

2389

            96.0,

2390

);

2391

        // PT_TO_PX is the documented factor — 1pt = 96/72 px.

2392

        approx(

2393

            pixel_value_to_pixels_fallback(&PixelValue::pt(1.0)).unwrap(),

2394

            PT_TO_PX,

2395

);

2396

2397

2398

    #[test]

2399

    fn pixel_value_to_pixels_fallback_keeps_the_sign_of_negative_lengths() {

2400

        for m in ABSOLUTE_METRICS {

2401

            let out = pixel_value_to_pixels_fallback(&PixelValue::from_metric(m, -4.0))

2402

                .expect("absolute metric resolves");

2403

            assert!(out < 0.0, "{m:?} produced {out} for -4");

2404

2405

2406

2407

    #[test]

2408

    fn pixel_value_to_pixels_fallback_returns_none_for_context_dependent_metrics() {

2409

        for m in CONTEXTUAL_METRICS {

2410

            assert_eq!(

2411

                pixel_value_to_pixels_fallback(&PixelValue::from_metric(m, 50.0)),

2412

                None,

2413

                "{m:?} must not be resolved without a containing block / viewport"

2414

);

2415

2416

2417

2418

    #[test]

2419

    fn pixel_value_to_pixels_fallback_sanitises_nan_and_infinite_inputs() {

2420

        // `FloatValue` stores `f32 * 1000` in an `isize` via an `as` cast, which

2421

        // saturates: NaN → 0, ±inf → isize::MIN/MAX. So no NaN and no infinity can

2422

        // reach the layout through a PixelValue, whatever the caller passes in.

2423

        assert_eq!(

2424

            pixel_value_to_pixels_fallback(&PixelValue::px(f32::NAN)),

2425

            Some(0.0),

2426

            "NaN must be flattened to 0, not propagated"

2427

);

2428

2429

        let pos = pixel_value_to_pixels_fallback(&PixelValue::px(f32::INFINITY))

2430

            .expect("px resolves");

2431

        assert!(pos.is_finite() && pos > 0.0, "+inf px became {pos}");

2432

2433

        let neg = pixel_value_to_pixels_fallback(&PixelValue::px(f32::NEG_INFINITY))

2434

            .expect("px resolves");

2435

        assert!(neg.is_finite() && neg < 0.0, "-inf px became {neg}");

2436

2437

2438

    #[test]

2439

    fn pixel_value_to_pixels_fallback_stays_finite_at_the_f32_extremes() {

2440

        for v in [f32::MAX, f32::MIN, f32::MIN_POSITIVE, -f32::MIN_POSITIVE] {

2441

            for m in ABSOLUTE_METRICS {

2442

                let out = pixel_value_to_pixels_fallback(&PixelValue::from_metric(m, v))

2443

                    .expect("absolute metric resolves");

2444

                assert!(out.is_finite(), "{m:?} at {v} overflowed to {out}");

2445

2446

2447

2448

2449

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

2450

    // minmax + translate_track

2451

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

2452

2453

    #[test]

2454

    fn minmax_puts_the_arguments_where_it_says_it_does() {

2455

        let t = minmax(

2456

            MinTrackSizingFunction::length(1.0),

2457

            MaxTrackSizingFunction::fr(2.0),

2458

);

2459

        assert_eq!(t.min, MinTrackSizingFunction::length(1.0));

2460

        assert_eq!(t.max, MaxTrackSizingFunction::fr(2.0));

2461

2462

2463

    #[test]

2464

    fn translate_track_maps_the_intrinsic_keywords() {

2465

        assert_eq!(

2466

            translate_track(&GridTrackSizing::MinContent),

2467

            minmax(

2468

                MinTrackSizingFunction::min_content(),

2469

                MaxTrackSizingFunction::min_content()

2470

2471

);

2472

        assert_eq!(

2473

            translate_track(&GridTrackSizing::MaxContent),

2474

            minmax(

2475

                MinTrackSizingFunction::max_content(),

2476

                MaxTrackSizingFunction::max_content()

2477

2478

);

2479

        // `auto` is minmax(min-content, max-content) per CSS Grid §7.2.

2480

        assert_eq!(

2481

            translate_track(&GridTrackSizing::Auto),

2482

            minmax(

2483

                MinTrackSizingFunction::min_content(),

2484

                MaxTrackSizingFunction::max_content()

2485

2486

);

2487

2488

2489

    #[test]

2490

    fn translate_track_resolves_fixed_tracks_through_the_absolute_unit_table() {

2491

        assert_eq!(

2492

            translate_track(&GridTrackSizing::Fixed(PixelValue::px(120.0))),

2493

            minmax(

2494

                MinTrackSizingFunction::length(120.0),

2495

                MaxTrackSizingFunction::length(120.0)

2496

2497

);

2498

        assert_eq!(

2499

            translate_track(&GridTrackSizing::Fixed(PixelValue::em(2.0))),

2500

            minmax(

2501

                MinTrackSizingFunction::length(32.0),

2502

                MaxTrackSizingFunction::length(32.0)

2503

2504

);

2505

        assert_eq!(

2506

            translate_track(&GridTrackSizing::FitContent(PixelValue::px(50.0))),

2507

            minmax(

2508

                MinTrackSizingFunction::length(50.0),

2509

                MaxTrackSizingFunction::max_content()

2510

2511

);

2512

2513

2514

    #[test]

2515

    fn translate_track_collapses_unresolvable_track_units_to_zero_px() {

2516

        // % / vw / vh cannot be expressed as a taffy track sizing fn here, and the

2517

        // `.unwrap_or(0.0)` inside translate_track turns them into a 0px track

2518

        // rather than dropping the track. Locking the (lossy) behaviour in.

2519

        for m in CONTEXTUAL_METRICS {

2520

            let pv = PixelValue::from_metric(m, 50.0);

2521

            assert_eq!(

2522

                translate_track(&GridTrackSizing::Fixed(pv)),

2523

                minmax(

2524

                    MinTrackSizingFunction::length(0.0),

2525

                    MaxTrackSizingFunction::length(0.0)

2526

),

2527

                "{m:?}"

2528

);

2529

            assert_eq!(

2530

                translate_track(&GridTrackSizing::FitContent(pv)),

2531

                minmax(

2532

                    MinTrackSizingFunction::length(0.0),

2533

                    MaxTrackSizingFunction::max_content()

2534

),

2535

                "{m:?}"

2536

);

2537

2538

2539

2540

    #[test]

2541

    fn translate_track_divides_fr_by_the_hundredfold_scaling_factor() {

2542

        assert_eq!(

2543

            translate_track(&GridTrackSizing::Fr(100)),

2544

            minmax(

2545

                MinTrackSizingFunction::auto(),

2546

                MaxTrackSizingFunction::fr(1.0)

2547

2548

);

2549

        assert_eq!(

2550

            translate_track(&GridTrackSizing::Fr(50)),

2551

            minmax(

2552

                MinTrackSizingFunction::auto(),

2553

                MaxTrackSizingFunction::fr(0.5)

2554

2555

);

2556

        assert_eq!(

2557

            translate_track(&GridTrackSizing::Fr(0)),

2558

            minmax(

2559

                MinTrackSizingFunction::auto(),

2560

                MaxTrackSizingFunction::fr(0.0)

2561

2562

);

2563

2564

2565

    #[test]

2566

    fn translate_track_does_not_overflow_at_the_fr_integer_bounds() {

2567

        for fr in [i32::MIN, i32::MIN + 1, -100, i32::MAX, i32::MAX - 1] {

2568

            let t = translate_track(&GridTrackSizing::Fr(fr));

2569

            let v = t.max.into_raw().value();

2570

            assert!(v.is_finite(), "Fr({fr}) produced a non-finite fr: {v}");

2571

            assert_eq!(v, fr as f32 / 100.0, "Fr({fr})");

2572

2573

2574

2575

    #[test]

2576

    fn translate_track_minmax_takes_the_min_of_the_min_and_the_max_of_the_max() {

2577

        let t = GridTrackSizing::MinMax(GridMinMax {

2578

            min: Box::new(GridTrackSizing::Fixed(PixelValue::px(10.0))),

2579

            max: Box::new(GridTrackSizing::Fr(200)),

2580

});

2581

        assert_eq!(

2582

            translate_track(&t),

2583

            minmax(

2584

                MinTrackSizingFunction::length(10.0),

2585

                MaxTrackSizingFunction::fr(2.0)

2586

2587

);

2588

2589

        // The *other* halves are discarded: only minmax_box.min.min and

2590

        // minmax_box.max.max survive the translation.

2591

        let t = GridTrackSizing::MinMax(GridMinMax {

2592

            min: Box::new(GridTrackSizing::MaxContent),

2593

            max: Box::new(GridTrackSizing::MinContent),

2594

});

2595

        assert_eq!(

2596

            translate_track(&t),

2597

            minmax(

2598

                MinTrackSizingFunction::max_content(),

2599

                MaxTrackSizingFunction::min_content()

2600

2601

);

2602

2603

2604

    #[test]

2605

    fn translate_track_terminates_on_a_left_nested_minmax_chain() {

2606

        // Nesting only on the `min` side keeps the recursion linear.

2607

        let mut t = GridTrackSizing::Fixed(PixelValue::px(7.0));

2608

        for _ in 0..64 {

2609

            t = GridTrackSizing::MinMax(GridMinMax {

2610

                min: Box::new(t),

2611

                max: Box::new(GridTrackSizing::MaxContent),

2612

});

2613

2614

        assert_eq!(

2615

            translate_track(&t),

2616

            minmax(

2617

                MinTrackSizingFunction::length(7.0),

2618

                MaxTrackSizingFunction::max_content()

2619

2620

);

2621

2622

2623

    #[test]

2624

    fn translate_track_terminates_on_a_doubly_nested_minmax_chain() {

2625

        // NOTE: translate_track calls itself on BOTH halves of a MinMax, so a

2626

        // minmax nested on both sides costs O(2^depth). CSS grammar forbids

2627

        // minmax() inside minmax(), so the parser can't reach this — but the type

2628

        // can express it. Depth 10 = ~1k calls; it must still terminate and pick

2629

        // the leaf on each side.

2630

        let mut t = GridTrackSizing::Fixed(PixelValue::px(3.0));

2631

        for _ in 0..10 {

2632

            t = GridTrackSizing::MinMax(GridMinMax {

2633

                min: Box::new(t.clone()),

2634

                max: Box::new(t),

2635

});

2636

2637

        assert_eq!(

2638

            translate_track(&t),

2639

            minmax(

2640

                MinTrackSizingFunction::length(3.0),

2641

                MaxTrackSizingFunction::length(3.0)

2642

2643

);

2644

2645

2646

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

2647

    // grid-template-* / grid-auto-* → taffy

2648

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

2649

2650

    #[test]

2651

    fn grid_templates_are_empty_for_every_non_exact_css_value() {

2652

        for v in [

2653

            CssPropertyValue::None,

2654

            CssPropertyValue::Inherit,

2655

            CssPropertyValue::Revert,

2656

            CssPropertyValue::Unset,

2657

            CssPropertyValue::Auto,

2658

            CssPropertyValue::Initial,

2659

] {

2660

            assert!(grid_template_rows_to_taffy(v.clone()).is_empty(), "{v:?}");

2661

            assert!(grid_template_columns_to_taffy(v).is_empty());

2662

2663

        assert!(grid_template_rows_to_taffy(CssPropertyValue::Exact(template(Vec::new()))).is_empty());

2664

2665

2666

    #[test]

2667

    fn grid_auto_tracks_are_empty_for_every_non_exact_css_value() {

2668

        for v in [

2669

            CssPropertyValue::None,

2670

            CssPropertyValue::Inherit,

2671

            CssPropertyValue::Revert,

2672

            CssPropertyValue::Unset,

2673

            CssPropertyValue::Auto,

2674

            CssPropertyValue::Initial,

2675

] {

2676

            assert!(grid_auto_rows_to_taffy(v.clone()).is_empty(), "{v:?}");

2677

            assert!(grid_auto_columns_to_taffy(v).is_empty());

2678

2679

2680

2681

    #[test]

2682

    fn grid_template_rows_and_columns_translate_each_track_in_order() {

2683

        let t = template(vec![

2684

            GridTrackSizing::Fr(100),

2685

            GridTrackSizing::Fixed(PixelValue::px(20.0)),

2686

            GridTrackSizing::Auto,

2687

]);

2688

        let rows = grid_template_rows_to_taffy(CssPropertyValue::Exact(t.clone()));

2689

        let cols = grid_template_columns_to_taffy(CssPropertyValue::Exact(t));

2690

2691

        assert_eq!(rows.len(), 3);

2692

        assert_eq!(rows, cols, "rows and columns share one translation path");

2693

        assert_eq!(

2694

            rows[0],

2695

            GridTemplateComponent::Single(minmax(

2696

                MinTrackSizingFunction::auto(),

2697

                MaxTrackSizingFunction::fr(1.0)

2698

))

2699

);

2700

        assert_eq!(

2701

            rows[1],

2702

            GridTemplateComponent::Single(minmax(

2703

                MinTrackSizingFunction::length(20.0),

2704

                MaxTrackSizingFunction::length(20.0)

2705

))

2706

);

2707

        assert_eq!(

2708

            rows[2],

2709

            GridTemplateComponent::Single(minmax(

2710

                MinTrackSizingFunction::min_content(),

2711

                MaxTrackSizingFunction::max_content()

2712

))

2713

);

2714

2715

2716

    #[test]

2717

    fn grid_auto_rows_and_columns_agree_on_every_track() {

2718

        let tracks = vec![

2719

            GridTrackSizing::Fr(250),

2720

            GridTrackSizing::MinContent,

2721

            GridTrackSizing::FitContent(PixelValue::px(9.0)),

2722

            GridTrackSizing::MinMax(GridMinMax {

2723

                min: Box::new(GridTrackSizing::Fixed(PixelValue::px(1.0))),

2724

                max: Box::new(GridTrackSizing::MaxContent),

2725

}),

2726

];

2727

        let rows = grid_auto_rows_to_taffy(CssPropertyValue::Exact(auto_tracks(tracks.clone())));

2728

        let cols = grid_auto_columns_to_taffy(CssPropertyValue::Exact(auto_tracks(tracks.clone())));

2729

2730

        assert_eq!(rows.len(), tracks.len());

2731

        // grid_auto_rows_to_taffy rebuilds the MinMax by calling translate_track

2732

        // twice; it must land on exactly the same value as the single-call path.

2733

        assert_eq!(rows, cols);

2734

        for (i, track) in tracks.iter().enumerate() {

2735

            assert_eq!(rows[i], translate_track(track), "track #{i}");

2736

2737

2738

2739

    #[test]

2740

    fn grid_templates_handle_a_very_long_track_list() {

2741

        let tracks: Vec<GridTrackSizing> = (0..2048).map(GridTrackSizing::Fr).collect();

2742

        let out = grid_template_columns_to_taffy(CssPropertyValue::Exact(template(tracks)));

2743

        assert_eq!(out.len(), 2048);

2744

        assert_eq!(

2745

            out[2047],

2746

            GridTemplateComponent::Single(minmax(

2747

                MinTrackSizingFunction::auto(),

2748

                MaxTrackSizingFunction::fr(20.47)

2749

))

2750

);

2751

2752

2753

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

2754

    // decode_compact_grid_line — numeric

2755

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

2756

2757

    #[test]

2758

    fn decode_compact_grid_line_maps_both_sentinels_to_auto() {

2759

        assert_eq!(

2760

            decode_compact_grid_line(azul_css::compact_cache::I16_AUTO),

2761

            GridPlacement::<String>::Auto

2762

);

2763

        assert_eq!(

2764

            decode_compact_grid_line(azul_css::compact_cache::I16_SENTINEL),

2765

            GridPlacement::<String>::Auto

2766

);

2767

        // i16::MAX *is* the sentinel, so the top of the range is Auto, not a line.

2768

        assert_eq!(

2769

            decode_compact_grid_line(i16::MAX),

2770

            GridPlacement::<String>::Auto

2771

);

2772

2773

2774

    #[test]

2775

    fn decode_compact_grid_line_zero_is_line_zero_not_auto() {

2776

        assert_eq!(

2777

            decode_compact_grid_line(0),

2778

            GridPlacement::<String>::from_line_index(0)

2779

);

2780

2781

2782

    #[test]

2783

    fn decode_compact_grid_line_positive_is_a_line_and_negative_is_a_span() {

2784

        assert_eq!(

2785

            decode_compact_grid_line(3),

2786

            GridPlacement::<String>::from_line_index(3)

2787

);

2788

        assert_eq!(

2789

            decode_compact_grid_line(32_765),

2790

            GridPlacement::<String>::from_line_index(32_765),

2791

            "the largest value below I16_SENTINEL_THRESHOLD is still a line"

2792

);

2793

        assert_eq!(

2794

            decode_compact_grid_line(-1),

2795

            GridPlacement::<String>::from_span(1)

2796

);

2797

        assert_eq!(

2798

            decode_compact_grid_line(-4),

2799

            GridPlacement::<String>::from_span(4)

2800

);

2801

        assert_eq!(

2802

            decode_compact_grid_line(-32_767),

2803

            GridPlacement::<String>::from_span(32_767)

2804

);

2805

2806

2807

    #[test]

2808

    fn decode_compact_grid_line_at_i16_min_overflows_the_negation() {

2809

        // `(-v) as u16` on i16::MIN: -(-32768) is not representable in i16.

2810

        // Debug builds panic ("attempt to negate with overflow"); release wraps

2811

        // back to i16::MIN, whose bit pattern as u16 is 32768. Neither is a

2812

        // sensible span. Accept both so the test is profile-independent, and see

2813

        // the report: this input should be rejected (or the negation widened to

2814

        // i32) inside decode_compact_grid_line.

2815

        let decoded = std::panic::catch_unwind(|| decode_compact_grid_line(i16::MIN));

2816

        match decoded {

2817

            Err(_) => { /* debug: overflow panic */ }

2818

            Ok(p) => assert_eq!(

2819

p,

2820

                GridPlacement::<String>::from_span(32_768),

2821

                "release build: the negation wraps"

2822

),

2823

2824

2825

2826

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

2827

    // grid_line_to_taffy / grid_placement_to_taffy

2828

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

2829

2830

    #[test]

2831

    fn grid_line_to_taffy_maps_auto_lines_and_spans() {

2832

        assert_eq!(

2833

            grid_line_to_taffy(&AzGridLine::Auto),

2834

            GridPlacement::<String>::Auto

2835

);

2836

        assert_eq!(

2837

            grid_line_to_taffy(&AzGridLine::Line(0)),

2838

            GridPlacement::<String>::from_line_index(0)

2839

);

2840

        assert_eq!(

2841

            grid_line_to_taffy(&AzGridLine::Line(4)),

2842

            GridPlacement::<String>::from_line_index(4)

2843

);

2844

        assert_eq!(

2845

            grid_line_to_taffy(&AzGridLine::Line(-2)),

2846

            GridPlacement::<String>::from_line_index(-2),

2847

            "negative lines count from the end of the explicit grid"

2848

);

2849

        assert_eq!(

2850

            grid_line_to_taffy(&AzGridLine::Span(3)),

2851

            GridPlacement::<String>::from_span(3)

2852

);

2853

        assert_eq!(

2854

            grid_line_to_taffy(&AzGridLine::Span(0)),

2855

            GridPlacement::<String>::from_span(0)

2856

);

2857

2858

2859

    #[test]

2860

    fn grid_line_to_taffy_truncates_out_of_range_line_numbers_instead_of_clamping() {

2861

        // azul stores grid lines as i32, taffy as i16 — the `as i16` cast wraps.

2862

        // A `grid-column: 70000` therefore silently becomes line 4464 rather than

2863

        // being clamped to i16::MAX. Documented here; see the report.

2864

        assert_eq!(

2865

            grid_line_to_taffy(&AzGridLine::Line(70_000)),

2866

            GridPlacement::<String>::from_line_index(70_000_i32 as i16)

2867

);

2868

        assert_eq!(

2869

            grid_line_to_taffy(&AzGridLine::Line(i32::MAX)),

2870

            GridPlacement::<String>::from_line_index(-1),

2871

            "i32::MAX wraps to line -1 — the far end of the grid"

2872

);

2873

        assert_eq!(

2874

            grid_line_to_taffy(&AzGridLine::Line(i32::MIN)),

2875

            GridPlacement::<String>::from_line_index(0)

2876

);

2877

2878

2879

    #[test]

2880

    fn grid_line_to_taffy_wraps_out_of_range_and_negative_spans() {

2881

        // `span -1` is not valid CSS, but the i32 → u16 cast turns it into the

2882

        // largest possible span rather than rejecting it.

2883

        assert_eq!(

2884

            grid_line_to_taffy(&AzGridLine::Span(-1)),

2885

            GridPlacement::<String>::from_span(u16::MAX)

2886

);

2887

        // `span 65536` wraps to `span 0`.

2888

        assert_eq!(

2889

            grid_line_to_taffy(&AzGridLine::Span(65_536)),

2890

            GridPlacement::<String>::from_span(0)

2891

);

2892

        assert_eq!(

2893

            grid_line_to_taffy(&AzGridLine::Span(i32::MIN)),

2894

            GridPlacement::<String>::from_span(0)

2895

);

2896

2897

2898

    #[test]

2899

    fn grid_line_to_taffy_named_lines_keep_their_name_and_split_on_the_span_count() {

2900

        let named = |name: &str, span: i32| {

2901

            AzGridLine::Named(NamedGridLine {

2902

                grid_line_name: name.into(),

2903

                span_count: span,

2904

})

2905

};

2906

2907

        assert_eq!(

2908

            grid_line_to_taffy(&named("sidebar", 0)),

2909

            GridPlacement::NamedLine("sidebar".to_string(), 0)

2910

);

2911

        assert_eq!(

2912

            grid_line_to_taffy(&named("sidebar", 2)),

2913

            GridPlacement::NamedSpan("sidebar".to_string(), 2)

2914

);

2915

        // A negative span_count is not > 0, so it falls back to a named *line*.

2916

        assert_eq!(

2917

            grid_line_to_taffy(&named("sidebar", -5)),

2918

            GridPlacement::NamedLine("sidebar".to_string(), 0)

2919

);

2920

        // Empty and non-ASCII names must survive the AzString → String hop.

2921

        assert_eq!(

2922

            grid_line_to_taffy(&named("", 0)),

2923

            GridPlacement::NamedLine(String::new(), 0)

2924

);

2925

        assert_eq!(

2926

            grid_line_to_taffy(&named("行 🎉 col", 1)),

2927

            GridPlacement::NamedSpan("行 🎉 col".to_string(), 1)

2928

);

2929

2930

2931

    #[test]

2932

    fn grid_line_to_taffy_named_span_count_wraps_at_u16() {

2933

        assert_eq!(

2934

            grid_line_to_taffy(&AzGridLine::Named(NamedGridLine {

2935

                grid_line_name: "x".into(),

2936

                span_count: 65_536,

2937

            })),

2938

            GridPlacement::NamedSpan("x".to_string(), 0),

2939

            "span_count 65536 wraps to a 0-track named span"

2940

);

2941

2942

2943

    #[test]

2944

    fn grid_placement_to_taffy_does_not_swap_start_and_end() {

2945

        let p = AzGridPlacement {

2946

            grid_start: AzGridLine::Line(2),

2947

            grid_end: AzGridLine::Span(3),

2948

};

2949

        let out = grid_placement_to_taffy(&p);

2950

        assert_eq!(out.start, GridPlacement::<String>::from_line_index(2));

2951

        assert_eq!(out.end, GridPlacement::<String>::from_span(3));

2952

2953

        let both_auto = AzGridPlacement {

2954

            grid_start: AzGridLine::Auto,

2955

            grid_end: AzGridLine::Auto,

2956

};

2957

        let out = grid_placement_to_taffy(&both_auto);

2958

        assert_eq!(out.start, GridPlacement::<String>::Auto);

2959

        assert_eq!(out.end, GridPlacement::<String>::Auto);

2960

2961

2962

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

2963

    // enum → taffy mapping tables

2964

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

2965

2966

    #[test]

2967

    fn layout_display_to_taffy_maps_flex_and_grid_and_folds_the_rest_into_block() {

2968

        assert_eq!(

2969

            layout_display_to_taffy(CssPropertyValue::Exact(LayoutDisplay::None)),

2970

            Display::None

2971

);

2972

        for d in [LayoutDisplay::Flex, LayoutDisplay::InlineFlex] {

2973

            assert_eq!(

2974

                layout_display_to_taffy(CssPropertyValue::Exact(d)),

2975

                Display::Flex,

2976

                "{d:?}"

2977

);

2978

2979

        for d in [LayoutDisplay::Grid, LayoutDisplay::InlineGrid] {

2980

            assert_eq!(

2981

                layout_display_to_taffy(CssPropertyValue::Exact(d)),

2982

                Display::Grid,

2983

                "{d:?}"

2984

);

2985

2986

        // Everything else — including `contents`, `table*` and `list-item` — is

2987

        // handed to taffy as a plain block box.

2988

        for d in [

2989

            LayoutDisplay::Block,

2990

            LayoutDisplay::Inline,

2991

            LayoutDisplay::InlineBlock,

2992

            LayoutDisplay::Table,

2993

            LayoutDisplay::TableCell,

2994

            LayoutDisplay::TableRow,

2995

            LayoutDisplay::FlowRoot,

2996

            LayoutDisplay::ListItem,

2997

            LayoutDisplay::Contents,

2998

] {

2999

            assert_eq!(

3000

                layout_display_to_taffy(CssPropertyValue::Exact(d)),

3001

                Display::Block,

3002

                "{d:?}"

3003

);

3004

3005

3006

3007

    #[test]

3008

    fn layout_display_to_taffy_distinguishes_css_wide_none_from_display_none() {

3009

        // `CssPropertyValue::None` means "the property is absent", NOT `display: none`.

3010

        // It must fall back to the initial value (block), or nothing would render.

3011

        assert_eq!(

3012

            layout_display_to_taffy(CssPropertyValue::None),

3013

            Display::Block

3014

);

3015

        assert_eq!(

3016

            layout_display_to_taffy(CssPropertyValue::Inherit),

3017

            Display::Block

3018

);

3019

        assert_eq!(

3020

            layout_display_to_taffy(CssPropertyValue::Auto),

3021

            Display::Block

3022

);

3023

        assert_eq!(

3024

            layout_display_to_taffy(CssPropertyValue::Exact(LayoutDisplay::None)),

3025

            Display::None,

3026

            "…but an explicit `display: none` still means none"

3027

);

3028

3029

3030

    #[test]

3031

    fn layout_position_to_taffy_and_from_layout_position_agree_on_every_variant() {

3032

        let all = [

3033

            LayoutPosition::Static,

3034

            LayoutPosition::Relative,

3035

            LayoutPosition::Absolute,

3036

            LayoutPosition::Fixed,

3037

            LayoutPosition::Sticky,

3038

];

3039

        for p in all {

3040

            assert_eq!(

3041

                layout_position_to_taffy(CssPropertyValue::Exact(p)),

3042

                from_layout_position(p),

3043

                "the two position paths disagree on {p:?}"

3044

);

3045

3046

        assert_eq!(from_layout_position(LayoutPosition::Static), Position::Relative);

3047

        assert_eq!(from_layout_position(LayoutPosition::Relative), Position::Relative);

3048

        assert_eq!(from_layout_position(LayoutPosition::Sticky), Position::Relative);

3049

        assert_eq!(from_layout_position(LayoutPosition::Absolute), Position::Absolute);

3050

        assert_eq!(from_layout_position(LayoutPosition::Fixed), Position::Absolute);

3051

        // Absent property → `static` → relative.

3052

        assert_eq!(layout_position_to_taffy(CssPropertyValue::None), Position::Relative);

3053

        assert_eq!(layout_position_to_taffy(CssPropertyValue::Inherit), Position::Relative);

3054

3055

3056

    #[test]

3057

    fn grid_auto_flow_to_taffy_maps_all_four_variants_and_defaults_to_row() {

3058

        assert_eq!(

3059

            grid_auto_flow_to_taffy(CssPropertyValue::Exact(LayoutGridAutoFlow::Row)),

3060

            GridAutoFlow::Row

3061

);

3062

        assert_eq!(

3063

            grid_auto_flow_to_taffy(CssPropertyValue::Exact(LayoutGridAutoFlow::Column)),

3064

            GridAutoFlow::Column

3065

);

3066

        assert_eq!(

3067

            grid_auto_flow_to_taffy(CssPropertyValue::Exact(LayoutGridAutoFlow::RowDense)),

3068

            GridAutoFlow::RowDense

3069

);

3070

        assert_eq!(

3071

            grid_auto_flow_to_taffy(CssPropertyValue::Exact(LayoutGridAutoFlow::ColumnDense)),

3072

            GridAutoFlow::ColumnDense

3073

);

3074

        for v in [

3075

            CssPropertyValue::None,

3076

            CssPropertyValue::Inherit,

3077

            CssPropertyValue::Revert,

3078

            CssPropertyValue::Unset,

3079

            CssPropertyValue::Auto,

3080

            CssPropertyValue::Initial,

3081

] {

3082

            assert_eq!(grid_auto_flow_to_taffy(v), GridAutoFlow::Row, "{v:?}");

3083

3084

3085

3086

    #[test]

3087

    fn layout_flex_direction_to_taffy_maps_all_four_variants_and_defaults_to_row() {

3088

        assert_eq!(

3089

            layout_flex_direction_to_taffy(CssPropertyValue::Exact(LayoutFlexDirection::Row)),

3090

            FlexDirection::Row

3091

);

3092

        assert_eq!(

3093

            layout_flex_direction_to_taffy(CssPropertyValue::Exact(LayoutFlexDirection::RowReverse)),

3094

            FlexDirection::RowReverse

3095

);

3096

        assert_eq!(

3097

            layout_flex_direction_to_taffy(CssPropertyValue::Exact(LayoutFlexDirection::Column)),

3098

            FlexDirection::Column

3099

);

3100

        assert_eq!(

3101

            layout_flex_direction_to_taffy(CssPropertyValue::Exact(

3102

                LayoutFlexDirection::ColumnReverse

3103

)),

3104

            FlexDirection::ColumnReverse

3105

);

3106

        assert_eq!(

3107

            layout_flex_direction_to_taffy(CssPropertyValue::Inherit),

3108

            FlexDirection::Row

3109

);

3110

3111

3112

    #[test]

3113

    fn layout_flex_wrap_to_taffy_maps_all_three_variants_and_defaults_to_nowrap() {

3114

        assert_eq!(

3115

            layout_flex_wrap_to_taffy(CssPropertyValue::Exact(LayoutFlexWrap::NoWrap)),

3116

            FlexWrap::NoWrap

3117

);

3118

        assert_eq!(

3119

            layout_flex_wrap_to_taffy(CssPropertyValue::Exact(LayoutFlexWrap::Wrap)),

3120

            FlexWrap::Wrap

3121

);

3122

        assert_eq!(

3123

            layout_flex_wrap_to_taffy(CssPropertyValue::Exact(LayoutFlexWrap::WrapReverse)),

3124

            FlexWrap::WrapReverse

3125

);

3126

        assert_eq!(

3127

            layout_flex_wrap_to_taffy(CssPropertyValue::Inherit),

3128

            FlexWrap::NoWrap

3129

);

3130

3131

3132

    #[test]

3133

    fn layout_align_items_to_taffy_maps_start_and_end_onto_the_flex_variants() {

3134

        assert_eq!(

3135

            layout_align_items_to_taffy(CssPropertyValue::Exact(LayoutAlignItems::Stretch)),

3136

            AlignItems::Stretch

3137

);

3138

        assert_eq!(

3139

            layout_align_items_to_taffy(CssPropertyValue::Exact(LayoutAlignItems::Center)),

3140

            AlignItems::Center

3141

);

3142

        assert_eq!(

3143

            layout_align_items_to_taffy(CssPropertyValue::Exact(LayoutAlignItems::Start)),

3144

            AlignItems::FlexStart

3145

);

3146

        assert_eq!(

3147

            layout_align_items_to_taffy(CssPropertyValue::Exact(LayoutAlignItems::End)),

3148

            AlignItems::FlexEnd

3149

);

3150

        assert_eq!(

3151

            layout_align_items_to_taffy(CssPropertyValue::Exact(LayoutAlignItems::Baseline)),

3152

            AlignItems::Baseline

3153

);

3154

        // Absent → the CSS initial value, `stretch`.

3155

        assert_eq!(

3156

            layout_align_items_to_taffy(CssPropertyValue::Inherit),

3157

            AlignItems::Stretch

3158

);

3159

3160

3161

    #[test]

3162

    fn layout_align_self_to_taffy_returns_none_only_for_auto() {

3163

        assert_eq!(

3164

            layout_align_self_to_taffy(CssPropertyValue::Exact(LayoutAlignSelf::Auto)),

3165

            None

3166

);

3167

        // `auto` is the initial value, so an absent property is None too — that is

3168

        // what lets taffy inherit the parent's align-items.

3169

        assert_eq!(layout_align_self_to_taffy(CssPropertyValue::Inherit), None);

3170

        assert_eq!(layout_align_self_to_taffy(CssPropertyValue::Initial), None);

3171

3172

        assert_eq!(

3173

            layout_align_self_to_taffy(CssPropertyValue::Exact(LayoutAlignSelf::Start)),

3174

            Some(AlignSelf::FlexStart)

3175

);

3176

        assert_eq!(

3177

            layout_align_self_to_taffy(CssPropertyValue::Exact(LayoutAlignSelf::End)),

3178

            Some(AlignSelf::FlexEnd)

3179

);

3180

        assert_eq!(

3181

            layout_align_self_to_taffy(CssPropertyValue::Exact(LayoutAlignSelf::Center)),

3182

            Some(AlignSelf::Center)

3183

);

3184

        assert_eq!(

3185

            layout_align_self_to_taffy(CssPropertyValue::Exact(LayoutAlignSelf::Baseline)),

3186

            Some(AlignSelf::Baseline)

3187

);

3188

        assert_eq!(

3189

            layout_align_self_to_taffy(CssPropertyValue::Exact(LayoutAlignSelf::Stretch)),

3190

            Some(AlignSelf::Stretch)

3191

);

3192

3193

3194

    #[test]

3195

    fn layout_align_content_to_taffy_maps_every_variant_and_defaults_to_stretch() {

3196

        assert_eq!(

3197

            layout_align_content_to_taffy(CssPropertyValue::Exact(LayoutAlignContent::Start)),

3198

            AlignContent::FlexStart

3199

);

3200

        assert_eq!(

3201

            layout_align_content_to_taffy(CssPropertyValue::Exact(LayoutAlignContent::End)),

3202

            AlignContent::FlexEnd

3203

);

3204

        assert_eq!(

3205

            layout_align_content_to_taffy(CssPropertyValue::Exact(LayoutAlignContent::Center)),

3206

            AlignContent::Center

3207

);

3208

        assert_eq!(

3209

            layout_align_content_to_taffy(CssPropertyValue::Exact(LayoutAlignContent::Stretch)),

3210

            AlignContent::Stretch

3211

);

3212

        assert_eq!(

3213

            layout_align_content_to_taffy(CssPropertyValue::Exact(

3214

                LayoutAlignContent::SpaceBetween

3215

)),

3216

            AlignContent::SpaceBetween

3217

);

3218

        assert_eq!(

3219

            layout_align_content_to_taffy(CssPropertyValue::Exact(

3220

                LayoutAlignContent::SpaceAround

3221

)),

3222

            AlignContent::SpaceAround

3223

);

3224

        assert_eq!(

3225

            layout_align_content_to_taffy(CssPropertyValue::Inherit),

3226

            AlignContent::Stretch

3227

);

3228

3229

3230

    #[test]

3231

    fn layout_justify_content_to_taffy_keeps_start_distinct_from_flex_start() {

3232

        assert_eq!(

3233

            layout_justify_content_to_taffy(CssPropertyValue::Exact(

3234

                LayoutJustifyContent::FlexStart

3235

)),

3236

            JustifyContent::FlexStart

3237

);

3238

        assert_eq!(

3239

            layout_justify_content_to_taffy(CssPropertyValue::Exact(LayoutJustifyContent::Start)),

3240

            JustifyContent::Start

3241

);

3242

        assert_ne!(JustifyContent::Start, JustifyContent::FlexStart);

3243

        assert_eq!(

3244

            layout_justify_content_to_taffy(CssPropertyValue::Exact(

3245

                LayoutJustifyContent::FlexEnd

3246

)),

3247

            JustifyContent::FlexEnd

3248

);

3249

        assert_eq!(

3250

            layout_justify_content_to_taffy(CssPropertyValue::Exact(LayoutJustifyContent::End)),

3251

            JustifyContent::End

3252

);

3253

        assert_eq!(

3254

            layout_justify_content_to_taffy(CssPropertyValue::Exact(LayoutJustifyContent::Center)),

3255

            JustifyContent::Center

3256

);

3257

        assert_eq!(

3258

            layout_justify_content_to_taffy(CssPropertyValue::Exact(

3259

                LayoutJustifyContent::SpaceBetween

3260

)),

3261

            JustifyContent::SpaceBetween

3262

);

3263

        assert_eq!(

3264

            layout_justify_content_to_taffy(CssPropertyValue::Exact(

3265

                LayoutJustifyContent::SpaceAround

3266

)),

3267

            JustifyContent::SpaceAround

3268

);

3269

        assert_eq!(

3270

            layout_justify_content_to_taffy(CssPropertyValue::Exact(

3271

                LayoutJustifyContent::SpaceEvenly

3272

)),

3273

            JustifyContent::SpaceEvenly

3274

);

3275

        // Initial value of justify-content in this codebase is `start`.

3276

        assert_eq!(

3277

            layout_justify_content_to_taffy(CssPropertyValue::Inherit),

3278

            JustifyContent::Start

3279

);

3280

3281

3282

    #[test]

3283

    fn layout_justify_items_to_taffy_maps_all_four_variants_and_defaults_to_stretch() {

3284

        assert_eq!(

3285

            layout_justify_items_to_taffy(CssPropertyValue::Exact(LayoutJustifyItems::Start)),

3286

            AlignItems::Start

3287

);

3288

        assert_eq!(

3289

            layout_justify_items_to_taffy(CssPropertyValue::Exact(LayoutJustifyItems::End)),

3290

            AlignItems::End

3291

);

3292

        assert_eq!(

3293

            layout_justify_items_to_taffy(CssPropertyValue::Exact(LayoutJustifyItems::Center)),

3294

            AlignItems::Center

3295

);

3296

        assert_eq!(

3297

            layout_justify_items_to_taffy(CssPropertyValue::Exact(LayoutJustifyItems::Stretch)),

3298

            AlignItems::Stretch

3299

);

3300

        assert_eq!(

3301

            layout_justify_items_to_taffy(CssPropertyValue::Inherit),

3302

            AlignItems::Stretch

3303

);

3304

        // justify-items uses the *logical* Start/End, unlike align-items, which is

3305

        // mapped onto FlexStart/FlexEnd. Guard the asymmetry.

3306

        assert_ne!(

3307

            layout_justify_items_to_taffy(CssPropertyValue::Exact(LayoutJustifyItems::Start)),

3308

            layout_align_items_to_taffy(CssPropertyValue::Exact(LayoutAlignItems::Start))

3309

);

3310

3311

3312

    #[test]

3313

    fn azul_overflow_to_taffy_treats_auto_as_scroll_and_everything_unset_as_visible() {

3314

        assert_eq!(

3315

            azul_overflow_to_taffy(MultiValue::Exact(LayoutOverflow::Visible)),

3316

            taffy::Overflow::Visible

3317

);

3318

        assert_eq!(

3319

            azul_overflow_to_taffy(MultiValue::Exact(LayoutOverflow::Hidden)),

3320

            taffy::Overflow::Hidden

3321

);

3322

        assert_eq!(

3323

            azul_overflow_to_taffy(MultiValue::Exact(LayoutOverflow::Scroll)),

3324

            taffy::Overflow::Scroll

3325

);

3326

        assert_eq!(

3327

            azul_overflow_to_taffy(MultiValue::Exact(LayoutOverflow::Clip)),

3328

            taffy::Overflow::Clip

3329

);

3330

        // Taffy has no `auto`; `auto` constrains the box exactly like `scroll`.

3331

        assert_eq!(

3332

            azul_overflow_to_taffy(MultiValue::Exact(LayoutOverflow::Auto)),

3333

            taffy::Overflow::Scroll

3334

);

3335

        for v in [MultiValue::Auto, MultiValue::Initial, MultiValue::Inherit] {

3336

            assert_eq!(azul_overflow_to_taffy(v), taffy::Overflow::Visible);

3337

3338

3339

3340

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

3341

    // css_width_to_px / css_height_to_px

3342

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

3343

3344

    #[test]

3345

    fn css_width_and_height_to_px_only_resolve_absolute_px_lengths() {

3346

        assert_eq!(

3347

            css_width_to_px(&LayoutWidth::Px(PixelValue::px(120.0))),

3348

            Some(120.0)

3349

);

3350

        assert_eq!(

3351

            css_height_to_px(&LayoutHeight::Px(PixelValue::px(120.0))),

3352

            Some(120.0)

3353

);

3354

        // em/rem go through the 16px fallback rather than returning None.

3355

        assert_eq!(

3356

            css_width_to_px(&LayoutWidth::Px(PixelValue::em(2.0))),

3357

            Some(32.0)

3358

);

3359

        assert_eq!(

3360

            css_height_to_px(&LayoutHeight::Px(PixelValue::rem(2.0))),

3361

            Some(32.0)

3362

);

3363

        // …but a percentage width has no containing block here.

3364

        assert_eq!(

3365

            css_width_to_px(&LayoutWidth::Px(PixelValue::percent(50.0))),

3366

            None

3367

);

3368

        assert_eq!(

3369

            css_height_to_px(&LayoutHeight::Px(PixelValue::percent(50.0))),

3370

            None

3371

);

3372

3373

3374

    #[test]

3375

    fn css_width_and_height_to_px_return_none_for_every_non_px_variant() {

3376

        let widths = [

3377

            LayoutWidth::Auto,

3378

            LayoutWidth::MinContent,

3379

            LayoutWidth::MaxContent,

3380

            LayoutWidth::FitContent(PixelValue::px(10.0)),

3381

            LayoutWidth::Calc(CalcAstItemVec::from_vec(vec![CalcAstItem::Value(

3382

                PixelValue::px(10.0),

3383

            )])),

3384

];

3385

        for w in &widths {

3386

            assert_eq!(css_width_to_px(w), None, "{w:?}");

3387

3388

3389

        let heights = [

3390

            LayoutHeight::Auto,

3391

            LayoutHeight::MinContent,

3392

            LayoutHeight::MaxContent,

3393

            LayoutHeight::FitContent(PixelValue::px(10.0)),

3394

            LayoutHeight::Calc(CalcAstItemVec::from_vec(Vec::new())),

3395

];

3396

        for h in &heights {

3397

            assert_eq!(css_height_to_px(h), None, "{h:?}");

3398

3399

3400

3401

    #[test]

3402

    fn css_width_to_px_never_returns_nan_for_a_nan_pixel_value() {

3403

        let w = css_width_to_px(&LayoutWidth::Px(PixelValue::px(f32::NAN)));

3404

        assert_eq!(w, Some(0.0));

3405

        let h = css_height_to_px(&LayoutHeight::Px(PixelValue::px(f32::INFINITY)));

3406

        assert!(h.expect("px resolves").is_finite());

3407

3408

3409

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

3410

    // MultiValue<PixelValue> → taffy lengths

3411

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

3412

3413

    #[test]

3414

    fn multi_value_to_lpa_maps_the_css_wide_keywords_to_auto() {

3415

        for mv in [MultiValue::Auto, MultiValue::Initial, MultiValue::Inherit] {

3416

            assert!(

3417

                multi_value_to_lpa(mv).is_auto(),

3418

                "inset keywords must stay auto"

3419

);

3420

3421

3422

3423

    #[test]

3424

    fn multi_value_to_lpa_resolves_lengths_percentages_and_falls_back_to_auto() {

3425

        assert_eq!(

3426

            multi_value_to_lpa(MultiValue::Exact(PixelValue::px(0.0))),

3427

            LengthPercentageAuto::length(0.0)

3428

);

3429

        assert_eq!(

3430

            multi_value_to_lpa(MultiValue::Exact(PixelValue::px(-12.5))),

3431

            LengthPercentageAuto::length(-12.5),

3432

            "negative insets are legal and must not be clamped"

3433

);

3434

        assert_eq!(

3435

            multi_value_to_lpa(MultiValue::Exact(PixelValue::percent(50.0))),

3436

            LengthPercentageAuto::percent(0.5),

3437

            "taffy percentages are 0..1, azul's are 0..100"

3438

);

3439

        assert_eq!(

3440

            multi_value_to_lpa(MultiValue::Exact(PixelValue::em(2.0))),

3441

            LengthPercentageAuto::length(32.0)

3442

);

3443

        // Viewport units resolve to neither a length nor a percent → auto.

3444

        for m in [SizeMetric::Vw, SizeMetric::Vh, SizeMetric::Vmin, SizeMetric::Vmax] {

3445

            assert!(

3446

                multi_value_to_lpa(MultiValue::Exact(PixelValue::from_metric(m, 10.0))).is_auto(),

3447

                "{m:?} is silently dropped to auto"

3448

);

3449

3450

3451

3452

    #[test]

3453

    fn multi_value_to_lpa_margin_keeps_auto_but_zeroes_the_other_keywords() {

3454

        // The whole point of the margin variant: `auto` survives (flex centering),

3455

        // `initial`/`inherit` become 0 (the CSS initial margin).

3456

        assert!(multi_value_to_lpa_margin(MultiValue::Auto).is_auto());

3457

        assert_eq!(

3458

            multi_value_to_lpa_margin(MultiValue::Initial),

3459

            LengthPercentageAuto::length(0.0)

3460

);

3461

        assert_eq!(

3462

            multi_value_to_lpa_margin(MultiValue::Inherit),

3463

            LengthPercentageAuto::length(0.0)

3464

);

3465

        // …which is exactly where it differs from the inset variant.

3466

        assert!(multi_value_to_lpa(MultiValue::Initial).is_auto());

3467

3468

3469

    #[test]

3470

    fn multi_value_to_lpa_margin_falls_back_to_zero_not_auto_for_unresolvable_units() {

3471

        assert_eq!(

3472

            multi_value_to_lpa_margin(MultiValue::Exact(PixelValue::from_metric(

3473

                SizeMetric::Vw,

3474

                10.0

3475

            ))),

3476

            LengthPercentageAuto::length(0.0),

3477

            "an unresolvable margin must not turn into `margin: auto` (it would centre the item)"

3478

);

3479

        assert_eq!(

3480

            multi_value_to_lpa_margin(MultiValue::Exact(PixelValue::percent(25.0))),

3481

            LengthPercentageAuto::percent(0.25)

3482

);

3483

        assert_eq!(

3484

            multi_value_to_lpa_margin(MultiValue::Exact(PixelValue::px(-8.0))),

3485

            LengthPercentageAuto::length(-8.0),

3486

            "negative margins are legal CSS"

3487

);

3488

        assert_eq!(

3489

            multi_value_to_lpa_margin(MultiValue::Exact(PixelValue::px(f32::NAN))),

3490

            LengthPercentageAuto::length(0.0)

3491

);

3492

3493

3494

    #[test]

3495

    fn multi_value_to_lp_maps_every_keyword_and_unresolvable_unit_to_zero() {

3496

        for mv in [MultiValue::Auto, MultiValue::Initial, MultiValue::Inherit] {

3497

            assert_eq!(multi_value_to_lp(mv), LengthPercentage::ZERO);

3498

3499

        for m in CONTEXTUAL_METRICS.iter().filter(|m| **m != SizeMetric::Percent) {

3500

            assert_eq!(

3501

                multi_value_to_lp(MultiValue::Exact(PixelValue::from_metric(*m, 10.0))),

3502

                LengthPercentage::ZERO,

3503

                "{m:?}"

3504

);

3505

3506

        assert_eq!(

3507

            multi_value_to_lp(MultiValue::Exact(PixelValue::px(4.0))),

3508

            LengthPercentage::length(4.0)

3509

);

3510

        assert_eq!(

3511

            multi_value_to_lp(MultiValue::Exact(PixelValue::percent(10.0))),

3512

            LengthPercentage::percent(0.1)

3513

);

3514

3515

3516

    #[test]

3517

    fn pixel_to_lp_agrees_with_multi_value_to_lp_on_every_exact_value() {

3518

        let values = [

3519

            PixelValue::px(0.0),

3520

            PixelValue::px(12.0),

3521

            PixelValue::px(-12.0),

3522

            PixelValue::px(f32::NAN),

3523

            PixelValue::px(f32::INFINITY),

3524

            PixelValue::em(1.5),

3525

            PixelValue::rem(1.5),

3526

            PixelValue::pt(12.0),

3527

            PixelValue::percent(33.0),

3528

            PixelValue::from_metric(SizeMetric::Vw, 100.0),

3529

            PixelValue::from_metric(SizeMetric::Vmax, 100.0),

3530

];

3531

        for pv in values {

3532

            assert_eq!(

3533

                pixel_to_lp(pv),

3534

                multi_value_to_lp(MultiValue::Exact(pv)),

3535

                "{pv:?}"

3536

);

3537

3538

        assert_eq!(

3539

            pixel_to_lp(PixelValue::from_metric(SizeMetric::Vw, 100.0)),

3540

            LengthPercentage::ZERO

3541

);

3542

3543

3544

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

3545

    // from_layout_width / from_layout_height / store_calc_and_make_dimension

3546

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

3547

3548

    #[allow(clippy::vec_box)] // return type must mirror the production calc_storage (Box = stable element addresses)

3549

    fn empty_calc_storage() -> std::cell::RefCell<Vec<Box<CalcResolveContext>>> {

3550

        std::cell::RefCell::new(Vec::new())

3551

3552

3553

    #[test]

3554

    fn from_layout_width_and_height_agree_on_every_shared_variant() {

3555

        let storage = empty_calc_storage();

3556

        let pairs: [(LayoutWidth, LayoutHeight); 6] = [

3557

            (LayoutWidth::Auto, LayoutHeight::Auto),

3558

3559

                LayoutWidth::Px(PixelValue::px(100.0)),

3560

                LayoutHeight::Px(PixelValue::px(100.0)),

3561

),

3562

3563

                LayoutWidth::Px(PixelValue::percent(50.0)),

3564

                LayoutHeight::Px(PixelValue::percent(50.0)),

3565

),

3566

            (LayoutWidth::MinContent, LayoutHeight::MinContent),

3567

            (LayoutWidth::MaxContent, LayoutHeight::MaxContent),

3568

3569

                LayoutWidth::FitContent(PixelValue::px(10.0)),

3570

                LayoutHeight::FitContent(PixelValue::px(10.0)),

3571

),

3572

];

3573

        for (w, h) in pairs {

3574

            assert_eq!(

3575

                from_layout_width(w.clone(), &storage, 16.0, 16.0),

3576

                from_layout_height(h, &storage, 16.0, 16.0),

3577

                "{w:?}"

3578

);

3579

3580

        assert!(storage.borrow().is_empty(), "no calc() → no storage growth");

3581

3582

3583

    #[test]

3584

    fn from_layout_width_maps_the_intrinsic_keywords_to_auto() {

3585

        let storage = empty_calc_storage();

3586

        for v in [

3587

            LayoutWidth::Auto,

3588

            LayoutWidth::MinContent,

3589

            LayoutWidth::MaxContent,

3590

            LayoutWidth::FitContent(PixelValue::px(10.0)),

3591

] {

3592

            assert_eq!(

3593

                from_layout_width(v.clone(), &storage, 16.0, 16.0),

3594

                Dimension::auto(),

3595

                "{v:?} is not forwarded to taffy — it becomes auto"

3596

);

3597

3598

3599

3600

    #[test]

3601

    fn from_layout_width_resolves_lengths_and_percentages_and_defaults_to_auto() {

3602

        let storage = empty_calc_storage();

3603

        assert_eq!(

3604

            from_layout_width(LayoutWidth::Px(PixelValue::px(0.0)), &storage, 16.0, 16.0),

3605

            Dimension::length(0.0)

3606

);

3607

        assert_eq!(

3608

            from_layout_width(LayoutWidth::Px(PixelValue::px(-50.0)), &storage, 16.0, 16.0),

3609

            Dimension::length(-50.0),

3610

            "a negative width is nonsense CSS, but the bridge passes it straight through"

3611

);

3612

        assert_eq!(

3613

            from_layout_width(

3614

                LayoutWidth::Px(PixelValue::percent(100.0)),

3615

                &storage,

3616

                16.0,

3617

                16.0

3618

),

3619

            Dimension::percent(1.0)

3620

);

3621

        assert_eq!(

3622

            from_layout_height(LayoutHeight::Px(PixelValue::em(3.0)), &storage, 16.0, 16.0),

3623

            Dimension::length(48.0),

3624

            "em uses the 16px fallback, NOT the em_size argument"

3625

);

3626

        // Viewport units cannot be resolved here → auto.

3627

        assert_eq!(

3628

            from_layout_width(

3629

                LayoutWidth::Px(PixelValue::from_metric(SizeMetric::Vw, 100.0)),

3630

                &storage,

3631

                16.0,

3632

                16.0

3633

),

3634

            Dimension::auto()

3635

);

3636

        // NaN is already flattened to 0 by PixelValue itself.

3637

        assert_eq!(

3638

            from_layout_width(LayoutWidth::Px(PixelValue::px(f32::NAN)), &storage, 16.0, 16.0),

3639

            Dimension::length(0.0)

3640

);

3641

        let huge = from_layout_height(

3642

            LayoutHeight::Px(PixelValue::px(f32::INFINITY)),

3643

            &storage,

3644

            16.0,

3645

            16.0,

3646

);

3647

        assert!(huge.value().is_finite(), "an infinite height reached taffy");

3648

3649

3650

    #[test]

3651

    fn from_layout_width_ignores_the_font_sizes_for_non_calc_values() {

3652

        // em_size/rem_size are only wired into the calc() context; the Px path uses

3653

        // the hard-coded 16px fallback. Passing NaN font sizes must therefore not

3654

        // corrupt a plain `width: 2em`.

3655

        let storage = empty_calc_storage();

3656

        assert_eq!(

3657

            from_layout_width(

3658

                LayoutWidth::Px(PixelValue::em(2.0)),

3659

                &storage,

3660

                f32::NAN,

3661

                f32::INFINITY

3662

),

3663

            Dimension::length(32.0)

3664

);

3665

3666

3667

    #[test]

3668

    fn from_layout_width_calc_produces_a_calc_dimension_and_pins_the_context() {

3669

        let storage = empty_calc_storage();

3670

        let items = CalcAstItemVec::from_vec(vec![

3671

            CalcAstItem::Value(PixelValue::percent(100.0)),

3672

            CalcAstItem::Sub,

3673

            CalcAstItem::Value(PixelValue::px(20.0)),

3674

]);

3675

        let d = from_layout_width(LayoutWidth::Calc(items), &storage, 20.0, 10.0);

3676

        let raw = d.into_raw();

3677

        assert!(raw.is_calc(), "calc() must reach taffy as a calc Dimension");

3678

        assert_eq!(storage.borrow().len(), 1);

3679

3680

        // SAFETY: the Box is still owned by `storage`, exactly as during a layout pass.

3681

        let ctx = unsafe { &*raw.calc_value().cast::<CalcResolveContext>() };

3682

        assert_eq!(ctx.em_size, 20.0);

3683

        assert_eq!(ctx.rem_size, 10.0);

3684

        assert_eq!(ctx.items.as_ref().len(), 3);

3685

3686

3687

    #[test]

3688

    fn store_calc_and_make_dimension_keeps_every_pointer_valid_across_vec_growth() {

3689

        // The whole reason for Box<CalcResolveContext>: the outer Vec reallocates

3690

        // many times while taffy is still holding raw pointers into it.

3691

        let storage = empty_calc_storage();

3692

        let dims: Vec<Dimension> = (0..256usize)

3693

            .map(|i| {

3694

                let items = CalcAstItemVec::from_vec(vec![CalcAstItem::Value(PixelValue::px(

3695

                    i as f32,

3696

                ))]);

3697

                store_calc_and_make_dimension(items, &storage, i as f32, 16.0)

3698

})

3699

            .collect();

3700

3701

        assert_eq!(storage.borrow().len(), 256);

3702

        for (i, d) in dims.iter().enumerate() {

3703

            let raw = d.into_raw();

3704

            assert!(raw.is_calc(), "#{i} is not a calc dimension");

3705

            // SAFETY: every Box is still alive in `storage`.

3706

            let ctx = unsafe { &*raw.calc_value().cast::<CalcResolveContext>() };

3707

            assert_eq!(

3708

                ctx.em_size, i as f32,

3709

                "context #{i} moved when the Vec reallocated"

3710

);

3711

            assert_eq!(ctx.rem_size, 16.0);

3712

            assert_eq!(ctx.items.as_ref().len(), 1);

3713

3714

3715

3716

    #[test]

3717

    fn store_calc_and_make_dimension_accepts_an_empty_ast_and_nan_font_sizes() {

3718

        let storage = empty_calc_storage();

3719

        let d = store_calc_and_make_dimension(

3720

            CalcAstItemVec::from_vec(Vec::new()),

3721

            &storage,

3722

            f32::NAN,

3723

            f32::INFINITY,

3724

);

3725

        let raw = d.into_raw();

3726

        assert!(raw.is_calc());

3727

        assert_eq!(storage.borrow().len(), 1);

3728

        // SAFETY: the Box is still owned by `storage`.

3729

        let ctx = unsafe { &*raw.calc_value().cast::<CalcResolveContext>() };

3730

        assert!(ctx.items.as_ref().is_empty());

3731

        assert!(

3732

            ctx.em_size.is_nan() && ctx.rem_size.is_infinite(),

3733

            "the font sizes are stored verbatim — evaluate_calc has to cope"

3734

);

3735

3736

3737

    #[test]

3738

    fn store_calc_and_make_dimension_hands_out_a_distinct_pointer_per_call() {

3739

        let storage = empty_calc_storage();

3740

        let a = store_calc_and_make_dimension(

3741

            CalcAstItemVec::from_vec(Vec::new()),

3742

            &storage,

3743

            1.0,

3744

            1.0,

3745

);

3746

        let b = store_calc_and_make_dimension(

3747

            CalcAstItemVec::from_vec(Vec::new()),

3748

            &storage,

3749

            2.0,

3750

            2.0,

3751

);

3752

        assert_ne!(

3753

            a.into_raw().calc_value(),

3754

            b.into_raw().calc_value(),

3755

            "two calc() values must not alias the same context"

3756

);

3757

        assert_ne!(a, b);

3758

3759

3760

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

3761

    // compute_taffy_scrollbar_info — needs a real StyledDom + LayoutTree

3762

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

3763

3764

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

3765

    mod with_layout_context {

3766

        use azul_core::{

3767

            dom::{Dom, DomId},

3768

            selection::TextSelection,

3769

};

3770

        use azul_css::{props::basic::FontRef, LayoutDebugMessage};

3771

3772

        use super::*;

3773

        use crate::{

3774

            font_traits::FontManager,

3775

            solver3::{cache, layout_tree::generate_layout_tree},

3776

};

3777

3778

        /// Owns everything a `LayoutContext` borrows.

3779

        struct Env {

3780

            styled_dom: StyledDom,

3781

            font_manager: FontManager<FontRef>,

3782

            text_selections: BTreeMap<DomId, TextSelection>,

3783

            counters: HashMap<(usize, String), i32>,

3784

            image_cache: azul_core::resources::ImageCache,

3785

            debug_messages: Option<Vec<LayoutDebugMessage>>,

3786

3787

3788

        impl Env {

3789

            fn new() -> Self {

3790

                let mut dom = Dom::create_body();

3791

                let (css, _warnings) = azul_css::parser2::new_from_str("");

3792

                Self {

3793

                    styled_dom: StyledDom::create(&mut dom, css),

3794

                    font_manager: FontManager::new(rust_fontconfig::FcFontCache::default())

3795

                        .expect("FontManager over an empty font cache"),

3796

                    text_selections: BTreeMap::new(),

3797

                    counters: HashMap::new(),

3798

                    image_cache: azul_core::resources::ImageCache::default(),

3799

                    debug_messages: None,

3800

3801

3802

3803

            fn ctx(&mut self) -> LayoutContext<'_, FontRef> {

3804

                LayoutContext {

3805

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

3806

                    style_cache: Default::default(),

3807

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

3808

                    styled_dom: &self.styled_dom,

3809

                    font_manager: &self.font_manager,

3810

                    text_selections: &self.text_selections,

3811

                    debug_messages: &mut self.debug_messages,

3812

                    counters: &mut self.counters,

3813

                    viewport_size: LogicalSize::new(800.0, 600.0),

3814

                    fragmentation_context: None,

3815

                    cursor_is_visible: true,

3816

                    cursor_locations: Vec::new(),

3817

                    preedit_text: None,

3818

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

3819

                    image_cache: &self.image_cache,

3820

                    content_overlay: None,

3821

                    system_style: None,

3822

                    get_system_time_fn: azul_core::task::GetSystemTimeCallback {

3823

                        cb: azul_core::task::get_system_time_libstd,

3824

},

3825

3826

3827

3828

3829

        #[test]

3830

        fn compute_taffy_scrollbar_info_returns_defaults_for_an_out_of_range_node() {

3831

            let mut env = Env::new();

3832

            let mut ctx = env.ctx();

3833

            let tree = generate_layout_tree(&mut ctx).expect("a plain body dom builds");

3834

3835

            for idx in [usize::MAX, tree.nodes.len(), tree.nodes.len() + 1] {

3836

                let (info, w, h) = compute_taffy_scrollbar_info(

3837

                    &ctx,

3838

                    &tree,

3839

                    idx,

3840

                    100.0,

3841

                    100.0,

3842

                    500.0,

3843

                    500.0,

3844

                    ContentSizeOrigin::BorderBox,

3845

);

3846

                assert!(!info.needs_horizontal, "#{idx}");

3847

                assert!(!info.needs_vertical, "#{idx}");

3848

                assert_eq!(w, 0.0);

3849

                assert_eq!(h, 0.0);

3850

3851

3852

3853

        #[test]

3854

        fn compute_taffy_scrollbar_info_never_reports_a_negative_or_nan_content_size() {

3855

            let mut env = Env::new();

3856

            let mut ctx = env.ctx();

3857

            let tree = generate_layout_tree(&mut ctx).expect("a plain body dom builds");

3858

            let root = tree.root;

3859

3860

            let extremes = [

3861

                0.0f32,

3862

                -1.0,

3863

                f32::NAN,

3864

                f32::INFINITY,

3865

                f32::NEG_INFINITY,

3866

                f32::MAX,

3867

                f32::MIN,

3868

];

3869

            for v in extremes {

3870

                for c in extremes {

3871

                    let (_info, w, h) = compute_taffy_scrollbar_info(

3872

                        &ctx,

3873

                        &tree,

3874

                        root,

3875

v,

3876

v,

3877

c,

3878

c,

3879

                        ContentSizeOrigin::BorderBox,

3880

);

3881

                    assert!(

3882

                        !w.is_nan() && w >= 0.0,

3883

                        "result={v} content={c} → content width {w}"

3884

);

3885

                    assert!(

3886

                        !h.is_nan() && h >= 0.0,

3887

                        "result={v} content={c} → content height {h}"

3888

);

3889

3890

3891

3892

3893

        #[test]

3894

        fn compute_taffy_scrollbar_info_needs_no_scrollbars_for_an_overflow_visible_body() {

3895

            let mut env = Env::new();

3896

            let mut ctx = env.ctx();

3897

            let tree = generate_layout_tree(&mut ctx).expect("a plain body dom builds");

3898

            let root = tree.root;

3899

3900

            // Content far larger than the box: `overflow: visible` still must not

3901

            // ask for scrollbars (only `auto`/`scroll` do).

3902

            let (info, w, h) = compute_taffy_scrollbar_info(

3903

                &ctx,

3904

                &tree,

3905

                root,

3906

                100.0,

3907

                100.0,

3908

                10_000.0,

3909

                10_000.0,

3910

                ContentSizeOrigin::BorderBox,

3911

);

3912

            assert!(!info.needs_horizontal);

3913

            assert!(!info.needs_vertical);

3914

            assert_eq!(info.scrollbar_width, 0.0);

3915

            assert_eq!(info.scrollbar_height, 0.0);

3916

            assert!(w > 0.0 && h > 0.0, "the taffy content size is passed back");

3917

3918

3919

3920