Grcov report - tabs.rs

1

//! Native-styled tab widget consisting of a [`TabHeader`] (the clickable tab bar)

2

//! and [`TabContent`] (the panel shown for the active tab).

3

//!

4

//! Styling emulates the Windows-native tab control appearance via inline CSS

5

//! constants.

6

7

use azul_core::{

8

    callbacks::{CoreCallback, CoreCallbackData, Update},

9

    dom::{Dom, DomVec, EventFilter, HoverEventFilter, IdOrClass, IdOrClass::Class, IdOrClassVec},

10

    refany::RefAny,

11

};

12

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

13

use azul_css::{

14

    dynamic_selector::{CssPropertyWithConditions, CssPropertyWithConditionsVec},

15

    props::{

16

        basic::*,

17

        layout::*,

18

        property::{CssProperty, *},

19

        style::*,

20

},

21

*,

22

};

23

use azul_css::css::BoxOrStatic;

24

25

use crate::callbacks::{Callback, CallbackInfo};

26

27

const STRING_16146701490593874959: AzString = AzString::from_const_str("system:ui");

28

const STYLE_BACKGROUND_CONTENT_8560341490937422656_ITEMS: &[StyleBackgroundContent] =

29

    &[StyleBackgroundContent::LinearGradient(LinearGradient {

30

        direction: Direction::FromTo(DirectionCorners {

31

            dir_from: DirectionCorner::Top,

32

            dir_to: DirectionCorner::Bottom,

33

}),

34

        extend_mode: ExtendMode::Clamp,

35

        stops: NormalizedLinearColorStopVec::from_const_slice(

36

            LINEAR_COLOR_STOP_1400070954008106244_ITEMS,

37

),

38

    })];

39

40

const STYLE_BACKGROUND_CONTENT_15534185073326444643_ITEMS: &[StyleBackgroundContent] =

41

    &[StyleBackgroundContent::LinearGradient(LinearGradient {

42

        direction: Direction::FromTo(DirectionCorners {

43

            dir_from: DirectionCorner::Top,

44

            dir_to: DirectionCorner::Bottom,

45

}),

46

        extend_mode: ExtendMode::Clamp,

47

        stops: NormalizedLinearColorStopVec::from_const_slice(

48

            LINEAR_COLOR_STOP_16259001466875079747_ITEMS,

49

),

50

    })];

51

const STYLE_BACKGROUND_CONTENT_16746671892555275291_ITEMS: &[StyleBackgroundContent] =

52

    &[StyleBackgroundContent::Color(ColorU {

53

        r: 255,

54

        g: 255,

55

        b: 255,

56

        a: 255,

57

    })];

58

const STYLE_FONT_FAMILY_8122988506401935406_ITEMS: &[StyleFontFamily] =

59

    &[StyleFontFamily::System(STRING_16146701490593874959)];

60

const LINEAR_COLOR_STOP_1400070954008106244_ITEMS: &[NormalizedLinearColorStop] = &[

61

    NormalizedLinearColorStop {

62

        offset: PercentageValue::const_new(0),

63

        color: ColorOrSystem::color(ColorU {

64

            r: 240,

65

            g: 240,

66

            b: 240,

67

            a: 255,

68

}),

69

},

70

    NormalizedLinearColorStop {

71

        offset: PercentageValue::const_new(100),

72

        color: ColorOrSystem::color(ColorU {

73

            r: 229,

74

            g: 229,

75

            b: 229,

76

            a: 255,

77

}),

78

},

79

];

80

const LINEAR_COLOR_STOP_16259001466875079747_ITEMS: &[NormalizedLinearColorStop] = &[

81

    NormalizedLinearColorStop {

82

        offset: PercentageValue::const_new(0),

83

        color: ColorOrSystem::color(ColorU {

84

            r: 236,

85

            g: 244,

86

            b: 252,

87

            a: 255,

88

}),

89

},

90

    NormalizedLinearColorStop {

91

        offset: PercentageValue::const_new(100),

92

        color: ColorOrSystem::color(ColorU {

93

            r: 221,

94

            g: 237,

95

            b: 252,

96

            a: 255,

97

}),

98

},

99

];

100

101

const CSS_MATCH_13824480602841492081_PROPERTIES: &[CssPropertyWithConditions] = &[

102

    // .__azul-native-tabs-header p.__azul-native-tabs-tab-not-active:hover

103

    CssPropertyWithConditions::on_hover(CssProperty::BorderBottomWidth(

104

        LayoutBorderBottomWidthValue::Exact(LayoutBorderBottomWidth {

105

            inner: PixelValue::const_px(1),

106

}),

107

)),

108

    CssPropertyWithConditions::on_hover(CssProperty::BorderLeftWidth(

109

        LayoutBorderLeftWidthValue::Exact(LayoutBorderLeftWidth {

110

            inner: PixelValue::const_px(1),

111

}),

112

)),

113

    CssPropertyWithConditions::on_hover(CssProperty::BorderRightWidth(

114

        LayoutBorderRightWidthValue::Exact(LayoutBorderRightWidth {

115

            inner: PixelValue::const_px(1),

116

}),

117

)),

118

    CssPropertyWithConditions::on_hover(CssProperty::BorderTopWidth(

119

        LayoutBorderTopWidthValue::Exact(LayoutBorderTopWidth {

120

            inner: PixelValue::const_px(1),

121

}),

122

)),

123

    CssPropertyWithConditions::on_hover(CssProperty::BorderBottomStyle(

124

        StyleBorderBottomStyleValue::Exact(StyleBorderBottomStyle {

125

            inner: BorderStyle::Solid,

126

}),

127

)),

128

    CssPropertyWithConditions::on_hover(CssProperty::BorderLeftStyle(

129

        StyleBorderLeftStyleValue::Exact(StyleBorderLeftStyle {

130

            inner: BorderStyle::Solid,

131

}),

132

)),

133

    CssPropertyWithConditions::on_hover(CssProperty::BorderRightStyle(

134

        StyleBorderRightStyleValue::Exact(StyleBorderRightStyle {

135

            inner: BorderStyle::Solid,

136

}),

137

)),

138

    CssPropertyWithConditions::on_hover(CssProperty::BorderTopStyle(

139

        StyleBorderTopStyleValue::Exact(StyleBorderTopStyle {

140

            inner: BorderStyle::Solid,

141

}),

142

)),

143

    CssPropertyWithConditions::on_hover(CssProperty::BorderBottomColor(

144

        StyleBorderBottomColorValue::Exact(StyleBorderBottomColor {

145

            inner: ColorU {

146

                r: 126,

147

                g: 180,

148

                b: 234,

149

                a: 255,

150

},

151

}),

152

)),

153

    CssPropertyWithConditions::on_hover(CssProperty::BorderLeftColor(

154

        StyleBorderLeftColorValue::Exact(StyleBorderLeftColor {

155

            inner: ColorU {

156

                r: 126,

157

                g: 180,

158

                b: 234,

159

                a: 255,

160

},

161

}),

162

)),

163

    CssPropertyWithConditions::on_hover(CssProperty::BorderRightColor(

164

        StyleBorderRightColorValue::Exact(StyleBorderRightColor {

165

            inner: ColorU {

166

                r: 126,

167

                g: 180,

168

                b: 234,

169

                a: 255,

170

},

171

}),

172

)),

173

    CssPropertyWithConditions::on_hover(CssProperty::BorderTopColor(

174

        StyleBorderTopColorValue::Exact(StyleBorderTopColor {

175

            inner: ColorU {

176

                r: 126,

177

                g: 180,

178

                b: 234,

179

                a: 255,

180

},

181

}),

182

)),

183

    CssPropertyWithConditions::on_hover(CssProperty::BackgroundContent(

184

        StyleBackgroundContentVecValue::Exact(StyleBackgroundContentVec::from_const_slice(

185

            STYLE_BACKGROUND_CONTENT_15534185073326444643_ITEMS,

186

)),

187

)),

188

    // .__azul-native-tabs-header p.__azul-native-tabs-tab-noleftborder

189

    CssPropertyWithConditions::simple(CssProperty::BorderLeftWidth(

190

        LayoutBorderLeftWidthValue::None,

191

)),

192

    CssPropertyWithConditions::simple(CssProperty::BorderLeftStyle(

193

        StyleBorderLeftStyleValue::None,

194

)),

195

    CssPropertyWithConditions::simple(CssProperty::BorderLeftColor(

196

        StyleBorderLeftColorValue::None,

197

)),

198

    // .__azul-native-tabs-header p.__azul-native-tabs-tab-not-active

199

    CssPropertyWithConditions::simple(CssProperty::PaddingRight(LayoutPaddingRightValue::Exact(

200

        LayoutPaddingRight {

201

            inner: PixelValue::const_px(5),

202

},

203

    ))),

204

    CssPropertyWithConditions::simple(CssProperty::PaddingLeft(LayoutPaddingLeftValue::Exact(

205

        LayoutPaddingLeft {

206

            inner: PixelValue::const_px(5),

207

},

208

    ))),

209

    CssPropertyWithConditions::simple(CssProperty::PaddingBottom(LayoutPaddingBottomValue::Exact(

210

        LayoutPaddingBottom {

211

            inner: PixelValue::const_px(1),

212

},

213

    ))),

214

    CssPropertyWithConditions::simple(CssProperty::PaddingTop(LayoutPaddingTopValue::Exact(

215

        LayoutPaddingTop {

216

            inner: PixelValue::const_px(1),

217

},

218

    ))),

219

    CssPropertyWithConditions::simple(CssProperty::MarginTop(LayoutMarginTopValue::Exact(

220

        LayoutMarginTop {

221

            inner: PixelValue::const_px(2),

222

},

223

    ))),

224

    // .__azul-native-tabs-header p

225

    CssPropertyWithConditions::simple(CssProperty::TextAlign(StyleTextAlignValue::Exact(

226

        StyleTextAlign::Center,

227

    ))),

228

    CssPropertyWithConditions::simple(CssProperty::Height(LayoutHeightValue::Exact(

229

        LayoutHeight::Px(PixelValue::const_px(21)),

230

    ))),

231

    CssPropertyWithConditions::simple(CssProperty::BorderBottomWidth(

232

        LayoutBorderBottomWidthValue::Exact(LayoutBorderBottomWidth {

233

            inner: PixelValue::const_px(1),

234

}),

235

)),

236

    CssPropertyWithConditions::simple(CssProperty::BorderLeftWidth(

237

        LayoutBorderLeftWidthValue::Exact(LayoutBorderLeftWidth {

238

            inner: PixelValue::const_px(1),

239

}),

240

)),

241

    CssPropertyWithConditions::simple(CssProperty::BorderRightWidth(

242

        LayoutBorderRightWidthValue::Exact(LayoutBorderRightWidth {

243

            inner: PixelValue::const_px(1),

244

}),

245

)),

246

    CssPropertyWithConditions::simple(CssProperty::BorderTopWidth(

247

        LayoutBorderTopWidthValue::Exact(LayoutBorderTopWidth {

248

            inner: PixelValue::const_px(1),

249

}),

250

)),

251

    CssPropertyWithConditions::simple(CssProperty::BorderBottomStyle(

252

        StyleBorderBottomStyleValue::Exact(StyleBorderBottomStyle {

253

            inner: BorderStyle::Solid,

254

}),

255

)),

256

    CssPropertyWithConditions::simple(CssProperty::BorderLeftStyle(

257

        StyleBorderLeftStyleValue::Exact(StyleBorderLeftStyle {

258

            inner: BorderStyle::Solid,

259

}),

260

)),

261

    CssPropertyWithConditions::simple(CssProperty::BorderRightStyle(

262

        StyleBorderRightStyleValue::Exact(StyleBorderRightStyle {

263

            inner: BorderStyle::Solid,

264

}),

265

)),

266

    CssPropertyWithConditions::simple(CssProperty::BorderTopStyle(

267

        StyleBorderTopStyleValue::Exact(StyleBorderTopStyle {

268

            inner: BorderStyle::Solid,

269

}),

270

)),

271

    CssPropertyWithConditions::simple(CssProperty::BorderBottomColor(

272

        StyleBorderBottomColorValue::Exact(StyleBorderBottomColor {

273

            inner: ColorU {

274

                r: 172,

275

                g: 172,

276

                b: 172,

277

                a: 255,

278

},

279

}),

280

)),

281

    CssPropertyWithConditions::simple(CssProperty::BorderLeftColor(

282

        StyleBorderLeftColorValue::Exact(StyleBorderLeftColor {

283

            inner: ColorU {

284

                r: 172,

285

                g: 172,

286

                b: 172,

287

                a: 255,

288

},

289

}),

290

)),

291

    CssPropertyWithConditions::simple(CssProperty::BorderRightColor(

292

        StyleBorderRightColorValue::Exact(StyleBorderRightColor {

293

            inner: ColorU {

294

                r: 172,

295

                g: 172,

296

                b: 172,

297

                a: 255,

298

},

299

}),

300

)),

301

    CssPropertyWithConditions::simple(CssProperty::BorderTopColor(

302

        StyleBorderTopColorValue::Exact(StyleBorderTopColor {

303

            inner: ColorU {

304

                r: 172,

305

                g: 172,

306

                b: 172,

307

                a: 255,

308

},

309

}),

310

)),

311

    CssPropertyWithConditions::simple(CssProperty::BackgroundContent(

312

        StyleBackgroundContentVecValue::Exact(StyleBackgroundContentVec::from_const_slice(

313

            STYLE_BACKGROUND_CONTENT_8560341490937422656_ITEMS,

314

)),

315

)),

316

    CssPropertyWithConditions::simple(CssProperty::AlignItems(LayoutAlignItemsValue::Exact(

317

        LayoutAlignItems::Center,

318

    ))),

319

];

320

const CSS_MATCH_13824480602841492081: CssPropertyWithConditionsVec =

321

    CssPropertyWithConditionsVec::from_const_slice(CSS_MATCH_13824480602841492081_PROPERTIES);

322

323

const CSS_MATCH_14575853790110873394_PROPERTIES: &[CssPropertyWithConditions] = &[

324

    // .__azul-native-tabs-header p.__azul-native-tabs-tab-active

325

    CssPropertyWithConditions::simple(CssProperty::PaddingRight(LayoutPaddingRightValue::Exact(

326

        LayoutPaddingRight {

327

            inner: PixelValue::const_px(7),

328

},

329

    ))),

330

    CssPropertyWithConditions::simple(CssProperty::PaddingLeft(LayoutPaddingLeftValue::Exact(

331

        LayoutPaddingLeft {

332

            inner: PixelValue::const_px(7),

333

},

334

    ))),

335

    CssPropertyWithConditions::simple(CssProperty::PaddingBottom(LayoutPaddingBottomValue::Exact(

336

        LayoutPaddingBottom {

337

            inner: PixelValue::const_px(3),

338

},

339

    ))),

340

    CssPropertyWithConditions::simple(CssProperty::PaddingTop(LayoutPaddingTopValue::Exact(

341

        LayoutPaddingTop {

342

            inner: PixelValue::const_px(3),

343

},

344

    ))),

345

    CssPropertyWithConditions::simple(CssProperty::Height(LayoutHeightValue::Exact(

346

        LayoutHeight::Px(PixelValue::const_px(23)),

347

    ))),

348

    CssPropertyWithConditions::simple(CssProperty::BoxSizing(LayoutBoxSizingValue::Exact(

349

        LayoutBoxSizing::ContentBox,

350

    ))),

351

    CssPropertyWithConditions::simple(CssProperty::BorderBottomWidth(

352

        LayoutBorderBottomWidthValue::Exact(LayoutBorderBottomWidth {

353

            inner: PixelValue::const_px(1),

354

}),

355

)),

356

    CssPropertyWithConditions::simple(CssProperty::BorderBottomStyle(

357

        StyleBorderBottomStyleValue::Exact(StyleBorderBottomStyle {

358

            inner: BorderStyle::Solid,

359

}),

360

)),

361

    CssPropertyWithConditions::simple(CssProperty::BorderBottomColor(

362

        StyleBorderBottomColorValue::Exact(StyleBorderBottomColor {

363

            inner: ColorU {

364

                r: 255,

365

                g: 255,

366

                b: 255,

367

                a: 255,

368

},

369

}),

370

)),

371

    CssPropertyWithConditions::simple(CssProperty::BackgroundContent(

372

        StyleBackgroundContentVecValue::Exact(StyleBackgroundContentVec::from_const_slice(

373

            STYLE_BACKGROUND_CONTENT_16746671892555275291_ITEMS,

374

)),

375

)),

376

    // .__azul-native-tabs-header p

377

    CssPropertyWithConditions::simple(CssProperty::TextAlign(StyleTextAlignValue::Exact(

378

        StyleTextAlign::Center,

379

    ))),

380

    CssPropertyWithConditions::simple(CssProperty::Height(LayoutHeightValue::Exact(

381

        LayoutHeight::Px(PixelValue::const_px(21)),

382

    ))),

383

    CssPropertyWithConditions::simple(CssProperty::BorderBottomWidth(

384

        LayoutBorderBottomWidthValue::Exact(LayoutBorderBottomWidth {

385

            inner: PixelValue::const_px(1),

386

}),

387

)),

388

    CssPropertyWithConditions::simple(CssProperty::BorderLeftWidth(

389

        LayoutBorderLeftWidthValue::Exact(LayoutBorderLeftWidth {

390

            inner: PixelValue::const_px(1),

391

}),

392

)),

393

    CssPropertyWithConditions::simple(CssProperty::BorderRightWidth(

394

        LayoutBorderRightWidthValue::Exact(LayoutBorderRightWidth {

395

            inner: PixelValue::const_px(1),

396

}),

397

)),

398

    CssPropertyWithConditions::simple(CssProperty::BorderTopWidth(

399

        LayoutBorderTopWidthValue::Exact(LayoutBorderTopWidth {

400

            inner: PixelValue::const_px(1),

401

}),

402

)),

403

    CssPropertyWithConditions::simple(CssProperty::BorderBottomStyle(

404

        StyleBorderBottomStyleValue::Exact(StyleBorderBottomStyle {

405

            inner: BorderStyle::Solid,

406

}),

407

)),

408

    CssPropertyWithConditions::simple(CssProperty::BorderLeftStyle(

409

        StyleBorderLeftStyleValue::Exact(StyleBorderLeftStyle {

410

            inner: BorderStyle::Solid,

411

}),

412

)),

413

    CssPropertyWithConditions::simple(CssProperty::BorderRightStyle(

414

        StyleBorderRightStyleValue::Exact(StyleBorderRightStyle {

415

            inner: BorderStyle::Solid,

416

}),

417

)),

418

    CssPropertyWithConditions::simple(CssProperty::BorderTopStyle(

419

        StyleBorderTopStyleValue::Exact(StyleBorderTopStyle {

420

            inner: BorderStyle::Solid,

421

}),

422

)),

423

    CssPropertyWithConditions::simple(CssProperty::BorderBottomColor(

424

        StyleBorderBottomColorValue::Exact(StyleBorderBottomColor {

425

            inner: ColorU {

426

                r: 172,

427

                g: 172,

428

                b: 172,

429

                a: 255,

430

},

431

}),

432

)),

433

    CssPropertyWithConditions::simple(CssProperty::BorderLeftColor(

434

        StyleBorderLeftColorValue::Exact(StyleBorderLeftColor {

435

            inner: ColorU {

436

                r: 172,

437

                g: 172,

438

                b: 172,

439

                a: 255,

440

},

441

}),

442

)),

443

    CssPropertyWithConditions::simple(CssProperty::BorderRightColor(

444

        StyleBorderRightColorValue::Exact(StyleBorderRightColor {

445

            inner: ColorU {

446

                r: 172,

447

                g: 172,

448

                b: 172,

449

                a: 255,

450

},

451

}),

452

)),

453

    CssPropertyWithConditions::simple(CssProperty::BorderTopColor(

454

        StyleBorderTopColorValue::Exact(StyleBorderTopColor {

455

            inner: ColorU {

456

                r: 172,

457

                g: 172,

458

                b: 172,

459

                a: 255,

460

},

461

}),

462

)),

463

    CssPropertyWithConditions::simple(CssProperty::BackgroundContent(

464

        StyleBackgroundContentVecValue::Exact(StyleBackgroundContentVec::from_const_slice(

465

            STYLE_BACKGROUND_CONTENT_8560341490937422656_ITEMS,

466

)),

467

)),

468

    CssPropertyWithConditions::simple(CssProperty::AlignItems(LayoutAlignItemsValue::Exact(

469

        LayoutAlignItems::Center,

470

    ))),

471

];

472

const CSS_MATCH_14575853790110873394: CssPropertyWithConditionsVec =

473

    CssPropertyWithConditionsVec::from_const_slice(CSS_MATCH_14575853790110873394_PROPERTIES);

474

475

const CSS_MATCH_17290739305197504468_PROPERTIES: &[CssPropertyWithConditions] = &[

476

    // .__azul-native-tabs-header .__azul-native-tabs-before-tabs

477

    CssPropertyWithConditions::simple(CssProperty::Width(LayoutWidthValue::Exact(

478

        LayoutWidth::Px(PixelValue::const_px(2)),

479

    ))),

480

    CssPropertyWithConditions::simple(CssProperty::FlexGrow(LayoutFlexGrowValue::Exact(

481

        LayoutFlexGrow {

482

            inner: FloatValue::const_new(1),

483

},

484

    ))),

485

    CssPropertyWithConditions::simple(CssProperty::BorderBottomWidth(

486

        LayoutBorderBottomWidthValue::Exact(LayoutBorderBottomWidth {

487

            inner: PixelValue::const_px(1),

488

}),

489

)),

490

    CssPropertyWithConditions::simple(CssProperty::BorderBottomStyle(

491

        StyleBorderBottomStyleValue::Exact(StyleBorderBottomStyle {

492

            inner: BorderStyle::Solid,

493

}),

494

)),

495

    CssPropertyWithConditions::simple(CssProperty::BorderBottomColor(

496

        StyleBorderBottomColorValue::Exact(StyleBorderBottomColor {

497

            inner: ColorU {

498

                r: 172,

499

                g: 172,

500

                b: 172,

501

                a: 255,

502

},

503

}),

504

)),

505

];

506

const CSS_MATCH_17290739305197504468: CssPropertyWithConditionsVec =

507

    CssPropertyWithConditionsVec::from_const_slice(CSS_MATCH_17290739305197504468_PROPERTIES);

508

509

const CSS_MATCH_18014909903571752977_PROPERTIES: &[CssPropertyWithConditions] = &[

510

    // .__azul-native-tabs-content

511

    CssPropertyWithConditions::simple(CssProperty::PaddingRight(LayoutPaddingRightValue::Exact(

512

        LayoutPaddingRight {

513

            inner: PixelValue::const_px(5),

514

},

515

    ))),

516

    CssPropertyWithConditions::simple(CssProperty::PaddingLeft(LayoutPaddingLeftValue::Exact(

517

        LayoutPaddingLeft {

518

            inner: PixelValue::const_px(5),

519

},

520

    ))),

521

    CssPropertyWithConditions::simple(CssProperty::PaddingBottom(LayoutPaddingBottomValue::Exact(

522

        LayoutPaddingBottom {

523

            inner: PixelValue::const_px(5),

524

},

525

    ))),

526

    CssPropertyWithConditions::simple(CssProperty::PaddingTop(LayoutPaddingTopValue::Exact(

527

        LayoutPaddingTop {

528

            inner: PixelValue::const_px(5),

529

},

530

    ))),

531

    CssPropertyWithConditions::simple(CssProperty::FlexGrow(LayoutFlexGrowValue::Exact(

532

        LayoutFlexGrow {

533

            inner: FloatValue::const_new(1),

534

},

535

    ))),

536

    CssPropertyWithConditions::simple(CssProperty::BorderTopWidth(LayoutBorderTopWidthValue::None)),

537

    CssPropertyWithConditions::simple(CssProperty::BorderTopStyle(StyleBorderTopStyleValue::None)),

538

    CssPropertyWithConditions::simple(CssProperty::BorderTopColor(StyleBorderTopColorValue::None)),

539

    CssPropertyWithConditions::simple(CssProperty::BorderBottomWidth(

540

        LayoutBorderBottomWidthValue::Exact(LayoutBorderBottomWidth {

541

            inner: PixelValue::const_px(1),

542

}),

543

)),

544

    CssPropertyWithConditions::simple(CssProperty::BorderLeftWidth(

545

        LayoutBorderLeftWidthValue::Exact(LayoutBorderLeftWidth {

546

            inner: PixelValue::const_px(1),

547

}),

548

)),

549

    CssPropertyWithConditions::simple(CssProperty::BorderRightWidth(

550

        LayoutBorderRightWidthValue::Exact(LayoutBorderRightWidth {

551

            inner: PixelValue::const_px(1),

552

}),

553

)),

554

    CssPropertyWithConditions::simple(CssProperty::BorderBottomStyle(

555

        StyleBorderBottomStyleValue::Exact(StyleBorderBottomStyle {

556

            inner: BorderStyle::Solid,

557

}),

558

)),

559

    CssPropertyWithConditions::simple(CssProperty::BorderLeftStyle(

560

        StyleBorderLeftStyleValue::Exact(StyleBorderLeftStyle {

561

            inner: BorderStyle::Solid,

562

}),

563

)),

564

    CssPropertyWithConditions::simple(CssProperty::BorderRightStyle(

565

        StyleBorderRightStyleValue::Exact(StyleBorderRightStyle {

566

            inner: BorderStyle::Solid,

567

}),

568

)),

569

    CssPropertyWithConditions::simple(CssProperty::BorderBottomColor(

570

        StyleBorderBottomColorValue::Exact(StyleBorderBottomColor {

571

            inner: ColorU {

572

                r: 172,

573

                g: 172,

574

                b: 172,

575

                a: 255,

576

},

577

}),

578

)),

579

    CssPropertyWithConditions::simple(CssProperty::BorderLeftColor(

580

        StyleBorderLeftColorValue::Exact(StyleBorderLeftColor {

581

            inner: ColorU {

582

                r: 172,

583

                g: 172,

584

                b: 172,

585

                a: 255,

586

},

587

}),

588

)),

589

    CssPropertyWithConditions::simple(CssProperty::BorderRightColor(

590

        StyleBorderRightColorValue::Exact(StyleBorderRightColor {

591

            inner: ColorU {

592

                r: 172,

593

                g: 172,

594

                b: 172,

595

                a: 255,

596

},

597

}),

598

)),

599

    CssPropertyWithConditions::simple(CssProperty::BackgroundContent(

600

        StyleBackgroundContentVecValue::Exact(StyleBackgroundContentVec::from_const_slice(

601

            STYLE_BACKGROUND_CONTENT_16746671892555275291_ITEMS,

602

)),

603

)),

604

];

605

const CSS_MATCH_18014909903571752977: CssPropertyWithConditionsVec =

606

    CssPropertyWithConditionsVec::from_const_slice(CSS_MATCH_18014909903571752977_PROPERTIES);

607

608

const CSS_MATCH_3088386549906605418_PROPERTIES: &[CssPropertyWithConditions] = &[

609

    // .__azul-native-tabs-header .__azul-native-tabs-after-tabs

610

    CssPropertyWithConditions::simple(CssProperty::FlexGrow(LayoutFlexGrowValue::Exact(

611

        LayoutFlexGrow {

612

            inner: FloatValue::const_new(1),

613

},

614

    ))),

615

    CssPropertyWithConditions::simple(CssProperty::BorderBottomWidth(

616

        LayoutBorderBottomWidthValue::Exact(LayoutBorderBottomWidth {

617

            inner: PixelValue::const_px(1),

618

}),

619

)),

620

    CssPropertyWithConditions::simple(CssProperty::BorderBottomStyle(

621

        StyleBorderBottomStyleValue::Exact(StyleBorderBottomStyle {

622

            inner: BorderStyle::Solid,

623

}),

624

)),

625

    CssPropertyWithConditions::simple(CssProperty::BorderBottomColor(

626

        StyleBorderBottomColorValue::Exact(StyleBorderBottomColor {

627

            inner: ColorU {

628

                r: 172,

629

                g: 172,

630

                b: 172,

631

                a: 255,

632

},

633

}),

634

)),

635

];

636

const CSS_MATCH_3088386549906605418: CssPropertyWithConditionsVec =

637

    CssPropertyWithConditionsVec::from_const_slice(CSS_MATCH_3088386549906605418_PROPERTIES);

638

639

const CSS_MATCH_4415083954137121609_PROPERTIES: &[CssPropertyWithConditions] = &[

640

    // .__azul-native-tabs-header p.__azul-native-tabs-tab-not-active:hover

641

    CssPropertyWithConditions::on_hover(CssProperty::BorderBottomWidth(

642

        LayoutBorderBottomWidthValue::Exact(LayoutBorderBottomWidth {

643

            inner: PixelValue::const_px(1),

644

}),

645

)),

646

    CssPropertyWithConditions::on_hover(CssProperty::BorderLeftWidth(

647

        LayoutBorderLeftWidthValue::Exact(LayoutBorderLeftWidth {

648

            inner: PixelValue::const_px(1),

649

}),

650

)),

651

    CssPropertyWithConditions::on_hover(CssProperty::BorderRightWidth(

652

        LayoutBorderRightWidthValue::Exact(LayoutBorderRightWidth {

653

            inner: PixelValue::const_px(1),

654

}),

655

)),

656

    CssPropertyWithConditions::on_hover(CssProperty::BorderTopWidth(

657

        LayoutBorderTopWidthValue::Exact(LayoutBorderTopWidth {

658

            inner: PixelValue::const_px(1),

659

}),

660

)),

661

    CssPropertyWithConditions::on_hover(CssProperty::BorderBottomStyle(

662

        StyleBorderBottomStyleValue::Exact(StyleBorderBottomStyle {

663

            inner: BorderStyle::Solid,

664

}),

665

)),

666

    CssPropertyWithConditions::on_hover(CssProperty::BorderLeftStyle(

667

        StyleBorderLeftStyleValue::Exact(StyleBorderLeftStyle {

668

            inner: BorderStyle::Solid,

669

}),

670

)),

671

    CssPropertyWithConditions::on_hover(CssProperty::BorderRightStyle(

672

        StyleBorderRightStyleValue::Exact(StyleBorderRightStyle {

673

            inner: BorderStyle::Solid,

674

}),

675

)),

676

    CssPropertyWithConditions::on_hover(CssProperty::BorderTopStyle(

677

        StyleBorderTopStyleValue::Exact(StyleBorderTopStyle {

678

            inner: BorderStyle::Solid,

679

}),

680

)),

681

    CssPropertyWithConditions::on_hover(CssProperty::BorderBottomColor(

682

        StyleBorderBottomColorValue::Exact(StyleBorderBottomColor {

683

            inner: ColorU {

684

                r: 126,

685

                g: 180,

686

                b: 234,

687

                a: 255,

688

},

689

}),

690

)),

691

    CssPropertyWithConditions::on_hover(CssProperty::BorderLeftColor(

692

        StyleBorderLeftColorValue::Exact(StyleBorderLeftColor {

693

            inner: ColorU {

694

                r: 126,

695

                g: 180,

696

                b: 234,

697

                a: 255,

698

},

699

}),

700

)),

701

    CssPropertyWithConditions::on_hover(CssProperty::BorderRightColor(

702

        StyleBorderRightColorValue::Exact(StyleBorderRightColor {

703

            inner: ColorU {

704

                r: 126,

705

                g: 180,

706

                b: 234,

707

                a: 255,

708

},

709

}),

710

)),

711

    CssPropertyWithConditions::on_hover(CssProperty::BorderTopColor(

712

        StyleBorderTopColorValue::Exact(StyleBorderTopColor {

713

            inner: ColorU {

714

                r: 126,

715

                g: 180,

716

                b: 234,

717

                a: 255,

718

},

719

}),

720

)),

721

    CssPropertyWithConditions::on_hover(CssProperty::BackgroundContent(

722

        StyleBackgroundContentVecValue::Exact(StyleBackgroundContentVec::from_const_slice(

723

            STYLE_BACKGROUND_CONTENT_15534185073326444643_ITEMS,

724

)),

725

)),

726

    // .__azul-native-tabs-header p.__azul-native-tabs-tab-norightborder

727

    CssPropertyWithConditions::simple(CssProperty::BorderRightWidth(

728

        LayoutBorderRightWidthValue::None,

729

)),

730

    CssPropertyWithConditions::simple(CssProperty::BorderRightStyle(

731

        StyleBorderRightStyleValue::None,

732

)),

733

    CssPropertyWithConditions::simple(CssProperty::BorderRightColor(

734

        StyleBorderRightColorValue::None,

735

)),

736

    // .__azul-native-tabs-header p.__azul-native-tabs-tab-not-active

737

    CssPropertyWithConditions::simple(CssProperty::PaddingRight(LayoutPaddingRightValue::Exact(

738

        LayoutPaddingRight {

739

            inner: PixelValue::const_px(5),

740

},

741

    ))),

742

    CssPropertyWithConditions::simple(CssProperty::PaddingLeft(LayoutPaddingLeftValue::Exact(

743

        LayoutPaddingLeft {

744

            inner: PixelValue::const_px(5),

745

},

746

    ))),

747

    CssPropertyWithConditions::simple(CssProperty::PaddingBottom(LayoutPaddingBottomValue::Exact(

748

        LayoutPaddingBottom {

749

            inner: PixelValue::const_px(1),

750

},

751

    ))),

752

    CssPropertyWithConditions::simple(CssProperty::PaddingTop(LayoutPaddingTopValue::Exact(

753

        LayoutPaddingTop {

754

            inner: PixelValue::const_px(1),

755

},

756

    ))),

757

    CssPropertyWithConditions::simple(CssProperty::MarginTop(LayoutMarginTopValue::Exact(

758

        LayoutMarginTop {

759

            inner: PixelValue::const_px(2),

760

},

761

    ))),

762

    // .__azul-native-tabs-header p

763

    CssPropertyWithConditions::simple(CssProperty::TextAlign(StyleTextAlignValue::Exact(

764

        StyleTextAlign::Center,

765

    ))),

766

    CssPropertyWithConditions::simple(CssProperty::Height(LayoutHeightValue::Exact(

767

        LayoutHeight::Px(PixelValue::const_px(21)),

768

    ))),

769

    CssPropertyWithConditions::simple(CssProperty::BorderBottomWidth(

770

        LayoutBorderBottomWidthValue::Exact(LayoutBorderBottomWidth {

771

            inner: PixelValue::const_px(1),

772

}),

773

)),

774

    CssPropertyWithConditions::simple(CssProperty::BorderLeftWidth(

775

        LayoutBorderLeftWidthValue::Exact(LayoutBorderLeftWidth {

776

            inner: PixelValue::const_px(1),

777

}),

778

)),

779

    CssPropertyWithConditions::simple(CssProperty::BorderRightWidth(

780

        LayoutBorderRightWidthValue::Exact(LayoutBorderRightWidth {

781

            inner: PixelValue::const_px(1),

782

}),

783

)),

784

    CssPropertyWithConditions::simple(CssProperty::BorderTopWidth(

785

        LayoutBorderTopWidthValue::Exact(LayoutBorderTopWidth {

786

            inner: PixelValue::const_px(1),

787

}),

788

)),

789

    CssPropertyWithConditions::simple(CssProperty::BorderBottomStyle(

790

        StyleBorderBottomStyleValue::Exact(StyleBorderBottomStyle {

791

            inner: BorderStyle::Solid,

792

}),

793

)),

794

    CssPropertyWithConditions::simple(CssProperty::BorderLeftStyle(

795

        StyleBorderLeftStyleValue::Exact(StyleBorderLeftStyle {

796

            inner: BorderStyle::Solid,

797

}),

798

)),

799

    CssPropertyWithConditions::simple(CssProperty::BorderRightStyle(

800

        StyleBorderRightStyleValue::Exact(StyleBorderRightStyle {

801

            inner: BorderStyle::Solid,

802

}),

803

)),

804

    CssPropertyWithConditions::simple(CssProperty::BorderTopStyle(

805

        StyleBorderTopStyleValue::Exact(StyleBorderTopStyle {

806

            inner: BorderStyle::Solid,

807

}),

808

)),

809

    CssPropertyWithConditions::simple(CssProperty::BorderBottomColor(

810

        StyleBorderBottomColorValue::Exact(StyleBorderBottomColor {

811

            inner: ColorU {

812

                r: 172,

813

                g: 172,

814

                b: 172,

815

                a: 255,

816

},

817

}),

818

)),

819

    CssPropertyWithConditions::simple(CssProperty::BorderLeftColor(

820

        StyleBorderLeftColorValue::Exact(StyleBorderLeftColor {

821

            inner: ColorU {

822

                r: 172,

823

                g: 172,

824

                b: 172,

825

                a: 255,

826

},

827

}),

828

)),

829

    CssPropertyWithConditions::simple(CssProperty::BorderRightColor(

830

        StyleBorderRightColorValue::Exact(StyleBorderRightColor {

831

            inner: ColorU {

832

                r: 172,

833

                g: 172,

834

                b: 172,

835

                a: 255,

836

},

837

}),

838

)),

839

    CssPropertyWithConditions::simple(CssProperty::BorderTopColor(

840

        StyleBorderTopColorValue::Exact(StyleBorderTopColor {

841

            inner: ColorU {

842

                r: 172,

843

                g: 172,

844

                b: 172,

845

                a: 255,

846

},

847

}),

848

)),

849

    CssPropertyWithConditions::simple(CssProperty::BackgroundContent(

850

        StyleBackgroundContentVecValue::Exact(StyleBackgroundContentVec::from_const_slice(

851

            STYLE_BACKGROUND_CONTENT_8560341490937422656_ITEMS,

852

)),

853

)),

854

    CssPropertyWithConditions::simple(CssProperty::AlignItems(LayoutAlignItemsValue::Exact(

855

        LayoutAlignItems::Center,

856

    ))),

857

];

858

const CSS_MATCH_4415083954137121609: CssPropertyWithConditionsVec =

859

    CssPropertyWithConditionsVec::from_const_slice(CSS_MATCH_4415083954137121609_PROPERTIES);

860

861

const CSS_MATCH_4738503469417034630_PROPERTIES: &[CssPropertyWithConditions] = &[

862

    // .__azul-native-tabs-container

863

    CssPropertyWithConditions::simple(CssProperty::PaddingRight(LayoutPaddingRightValue::Exact(

864

        LayoutPaddingRight {

865

            inner: PixelValue::const_px(5),

866

},

867

    ))),

868

    CssPropertyWithConditions::simple(CssProperty::PaddingLeft(LayoutPaddingLeftValue::Exact(

869

        LayoutPaddingLeft {

870

            inner: PixelValue::const_px(5),

871

},

872

    ))),

873

    CssPropertyWithConditions::simple(CssProperty::PaddingBottom(LayoutPaddingBottomValue::Exact(

874

        LayoutPaddingBottom {

875

            inner: PixelValue::const_px(5),

876

},

877

    ))),

878

    CssPropertyWithConditions::simple(CssProperty::PaddingTop(LayoutPaddingTopValue::Exact(

879

        LayoutPaddingTop {

880

            inner: PixelValue::const_px(5),

881

},

882

    ))),

883

    CssPropertyWithConditions::simple(CssProperty::FlexGrow(LayoutFlexGrowValue::Exact(

884

        LayoutFlexGrow {

885

            inner: FloatValue::const_new(1),

886

},

887

    ))),

888

];

889

const CSS_MATCH_4738503469417034630: CssPropertyWithConditionsVec =

890

    CssPropertyWithConditionsVec::from_const_slice(CSS_MATCH_4738503469417034630_PROPERTIES);

891

892

const CSS_MATCH_9988039989460234263_PROPERTIES: &[CssPropertyWithConditions] = &[

893

    // .__azul-native-tabs-header

894

    CssPropertyWithConditions::simple(CssProperty::FontSize(StyleFontSizeValue::Exact(

895

        StyleFontSize {

896

            inner: PixelValue::const_px(11),

897

},

898

    ))),

899

    CssPropertyWithConditions::simple(CssProperty::FontFamily(StyleFontFamilyVecValue::Exact(

900

        StyleFontFamilyVec::from_const_slice(STYLE_FONT_FAMILY_8122988506401935406_ITEMS),

901

    ))),

902

    CssPropertyWithConditions::simple(CssProperty::FlexDirection(LayoutFlexDirectionValue::Exact(

903

        LayoutFlexDirection::Row,

904

    ))),

905

];

906

const CSS_MATCH_9988039989460234263: CssPropertyWithConditionsVec =

907

    CssPropertyWithConditionsVec::from_const_slice(CSS_MATCH_9988039989460234263_PROPERTIES);

908

909

// -- NO PADDING

910

const CSS_MATCH_18014909903571752977_PROPERTIES_NO_PADDING: &[CssPropertyWithConditions] = &[

911

    // .__azul-native-tabs-content

912

    CssPropertyWithConditions::simple(CssProperty::FlexGrow(LayoutFlexGrowValue::Exact(

913

        LayoutFlexGrow {

914

            inner: FloatValue::const_new(1),

915

},

916

    ))),

917

    CssPropertyWithConditions::simple(CssProperty::BackgroundContent(

918

        StyleBackgroundContentVecValue::Exact(StyleBackgroundContentVec::from_const_slice(

919

            STYLE_BACKGROUND_CONTENT_16746671892555275291_ITEMS,

920

)),

921

)),

922

];

923

const CSS_MATCH_18014909903571752977_NO_PADDING: CssPropertyWithConditionsVec =

924

    CssPropertyWithConditionsVec::from_const_slice(

925

        CSS_MATCH_18014909903571752977_PROPERTIES_NO_PADDING,

926

);

927

928

const CSS_MATCH_4738503469417034630_PROPERTIES_NO_PADDING: &[CssPropertyWithConditions] = &[

929

    // .__azul-native-tabs-container

930

    CssPropertyWithConditions::simple(CssProperty::FlexGrow(LayoutFlexGrowValue::Exact(

931

        LayoutFlexGrow {

932

            inner: FloatValue::const_new(1),

933

},

934

    ))),

935

];

936

const CSS_MATCH_4738503469417034630_NO_PADDING: CssPropertyWithConditionsVec =

937

    CssPropertyWithConditionsVec::from_const_slice(

938

        CSS_MATCH_4738503469417034630_PROPERTIES_NO_PADDING,

939

);

940

941

// -- REGULAR_INACTIVE_TAB

942

943

const CSS_MATCH_11510695043643111367_PROPERTIES: &[CssPropertyWithConditions] = &[

944

    // .__azul-native-tabs-header p.__azul-native-tabs-tab-not-active:hover

945

    CssPropertyWithConditions::on_hover(CssProperty::BorderBottomWidth(

946

        LayoutBorderBottomWidthValue::Exact(LayoutBorderBottomWidth {

947

            inner: PixelValue::const_px(1),

948

}),

949

)),

950

    CssPropertyWithConditions::on_hover(CssProperty::BorderLeftWidth(

951

        LayoutBorderLeftWidthValue::Exact(LayoutBorderLeftWidth {

952

            inner: PixelValue::const_px(1),

953

}),

954

)),

955

    CssPropertyWithConditions::on_hover(CssProperty::BorderRightWidth(

956

        LayoutBorderRightWidthValue::Exact(LayoutBorderRightWidth {

957

            inner: PixelValue::const_px(1),

958

}),

959

)),

960

    CssPropertyWithConditions::on_hover(CssProperty::BorderTopWidth(

961

        LayoutBorderTopWidthValue::Exact(LayoutBorderTopWidth {

962

            inner: PixelValue::const_px(1),

963

}),

964

)),

965

    CssPropertyWithConditions::on_hover(CssProperty::BorderBottomStyle(

966

        StyleBorderBottomStyleValue::Exact(StyleBorderBottomStyle {

967

            inner: BorderStyle::Solid,

968

}),

969

)),

970

    CssPropertyWithConditions::on_hover(CssProperty::BorderLeftStyle(

971

        StyleBorderLeftStyleValue::Exact(StyleBorderLeftStyle {

972

            inner: BorderStyle::Solid,

973

}),

974

)),

975

    CssPropertyWithConditions::on_hover(CssProperty::BorderRightStyle(

976

        StyleBorderRightStyleValue::Exact(StyleBorderRightStyle {

977

            inner: BorderStyle::Solid,

978

}),

979

)),

980

    CssPropertyWithConditions::on_hover(CssProperty::BorderTopStyle(

981

        StyleBorderTopStyleValue::Exact(StyleBorderTopStyle {

982

            inner: BorderStyle::Solid,

983

}),

984

)),

985

    CssPropertyWithConditions::on_hover(CssProperty::BorderBottomColor(

986

        StyleBorderBottomColorValue::Exact(StyleBorderBottomColor {

987

            inner: ColorU {

988

                r: 126,

989

                g: 180,

990

                b: 234,

991

                a: 255,

992

},

993

}),

994

)),

995

    CssPropertyWithConditions::on_hover(CssProperty::BorderLeftColor(

996

        StyleBorderLeftColorValue::Exact(StyleBorderLeftColor {

997

            inner: ColorU {

998

                r: 126,

999

                g: 180,

1000

                b: 234,

1001

                a: 255,

1002

},

1003

}),

1004

)),

1005

    CssPropertyWithConditions::on_hover(CssProperty::BorderRightColor(

1006

        StyleBorderRightColorValue::Exact(StyleBorderRightColor {

1007

            inner: ColorU {

1008

                r: 126,

1009

                g: 180,

1010

                b: 234,

1011

                a: 255,

1012

},

1013

}),

1014

)),

1015

    CssPropertyWithConditions::on_hover(CssProperty::BorderTopColor(

1016

        StyleBorderTopColorValue::Exact(StyleBorderTopColor {

1017

            inner: ColorU {

1018

                r: 126,

1019

                g: 180,

1020

                b: 234,

1021

                a: 255,

1022

},

1023

}),

1024

)),

1025

    CssPropertyWithConditions::on_hover(CssProperty::BackgroundContent(

1026

        StyleBackgroundContentVecValue::Exact(StyleBackgroundContentVec::from_const_slice(

1027

            STYLE_BACKGROUND_CONTENT_15534185073326444643_ITEMS,

1028

)),

1029

)),

1030

    // .__azul-native-tabs-header p.__azul-native-tabs-tab-not-active

1031

    CssPropertyWithConditions::simple(CssProperty::PaddingRight(LayoutPaddingRightValue::Exact(

1032

        LayoutPaddingRight {

1033

            inner: PixelValue::const_px(5),

1034

},

1035

    ))),

1036

    CssPropertyWithConditions::simple(CssProperty::PaddingLeft(LayoutPaddingLeftValue::Exact(

1037

        LayoutPaddingLeft {

1038

            inner: PixelValue::const_px(5),

1039

},

1040

    ))),

1041

    CssPropertyWithConditions::simple(CssProperty::PaddingBottom(LayoutPaddingBottomValue::Exact(

1042

        LayoutPaddingBottom {

1043

            inner: PixelValue::const_px(1),

1044

},

1045

    ))),

1046

    CssPropertyWithConditions::simple(CssProperty::PaddingTop(LayoutPaddingTopValue::Exact(

1047

        LayoutPaddingTop {

1048

            inner: PixelValue::const_px(1),

1049

},

1050

    ))),

1051

    CssPropertyWithConditions::simple(CssProperty::MarginTop(LayoutMarginTopValue::Exact(

1052

        LayoutMarginTop {

1053

            inner: PixelValue::const_px(2),

1054

},

1055

    ))),

1056

    // .__azul-native-tabs-header p

1057

    CssPropertyWithConditions::simple(CssProperty::TextAlign(StyleTextAlignValue::Exact(

1058

        StyleTextAlign::Center,

1059

    ))),

1060

    CssPropertyWithConditions::simple(CssProperty::Height(LayoutHeightValue::Exact(

1061

        LayoutHeight::Px(PixelValue::const_px(21)),

1062

    ))),

1063

    CssPropertyWithConditions::simple(CssProperty::BorderBottomWidth(

1064

        LayoutBorderBottomWidthValue::Exact(LayoutBorderBottomWidth {

1065

            inner: PixelValue::const_px(1),

1066

}),

1067

)),

1068

    CssPropertyWithConditions::simple(CssProperty::BorderLeftWidth(

1069

        LayoutBorderLeftWidthValue::Exact(LayoutBorderLeftWidth {

1070

            inner: PixelValue::const_px(1),

1071

}),

1072

)),

1073

    CssPropertyWithConditions::simple(CssProperty::BorderRightWidth(

1074

        LayoutBorderRightWidthValue::Exact(LayoutBorderRightWidth {

1075

            inner: PixelValue::const_px(1),

1076

}),

1077

)),

1078

    CssPropertyWithConditions::simple(CssProperty::BorderTopWidth(

1079

        LayoutBorderTopWidthValue::Exact(LayoutBorderTopWidth {

1080

            inner: PixelValue::const_px(1),

1081

}),

1082

)),

1083

    CssPropertyWithConditions::simple(CssProperty::BorderBottomStyle(

1084

        StyleBorderBottomStyleValue::Exact(StyleBorderBottomStyle {

1085

            inner: BorderStyle::Solid,

1086

}),

1087

)),

1088

    CssPropertyWithConditions::simple(CssProperty::BorderLeftStyle(

1089

        StyleBorderLeftStyleValue::Exact(StyleBorderLeftStyle {

1090

            inner: BorderStyle::Solid,

1091

}),

1092

)),

1093

    CssPropertyWithConditions::simple(CssProperty::BorderRightStyle(

1094

        StyleBorderRightStyleValue::Exact(StyleBorderRightStyle {

1095

            inner: BorderStyle::Solid,

1096

}),

1097

)),

1098

    CssPropertyWithConditions::simple(CssProperty::BorderTopStyle(

1099

        StyleBorderTopStyleValue::Exact(StyleBorderTopStyle {

1100

            inner: BorderStyle::Solid,

1101

}),

1102

)),

1103

    CssPropertyWithConditions::simple(CssProperty::BorderBottomColor(

1104

        StyleBorderBottomColorValue::Exact(StyleBorderBottomColor {

1105

            inner: ColorU {

1106

                r: 172,

1107

                g: 172,

1108

                b: 172,

1109

                a: 255,

1110

},

1111

}),

1112

)),

1113

    CssPropertyWithConditions::simple(CssProperty::BorderLeftColor(

1114

        StyleBorderLeftColorValue::Exact(StyleBorderLeftColor {

1115

            inner: ColorU {

1116

                r: 172,

1117

                g: 172,

1118

                b: 172,

1119

                a: 255,

1120

},

1121

}),

1122

)),

1123

    CssPropertyWithConditions::simple(CssProperty::BorderRightColor(

1124

        StyleBorderRightColorValue::Exact(StyleBorderRightColor {

1125

            inner: ColorU {

1126

                r: 172,

1127

                g: 172,

1128

                b: 172,

1129

                a: 255,

1130

},

1131

}),

1132

)),

1133

    CssPropertyWithConditions::simple(CssProperty::BorderTopColor(

1134

        StyleBorderTopColorValue::Exact(StyleBorderTopColor {

1135

            inner: ColorU {

1136

                r: 172,

1137

                g: 172,

1138

                b: 172,

1139

                a: 255,

1140

},

1141

}),

1142

)),

1143

    CssPropertyWithConditions::simple(CssProperty::BackgroundContent(

1144

        StyleBackgroundContentVecValue::Exact(StyleBackgroundContentVec::from_const_slice(

1145

            STYLE_BACKGROUND_CONTENT_8560341490937422656_ITEMS,

1146

)),

1147

)),

1148

    CssPropertyWithConditions::simple(CssProperty::AlignItems(LayoutAlignItemsValue::Exact(

1149

        LayoutAlignItems::Center,

1150

    ))),

1151

];

1152

const CSS_MATCH_11510695043643111367: CssPropertyWithConditionsVec =

1153

    CssPropertyWithConditionsVec::from_const_slice(CSS_MATCH_11510695043643111367_PROPERTIES);

1154

1155

/// Header bar for a tab widget, containing the clickable tab labels.

1156

#[derive(Debug, Clone)]

1157

#[repr(C)]

1158

pub struct TabHeader {

1159

    /// Labels for each tab.

1160

    pub tabs: StringVec,

1161

    /// Zero-based index of the currently active tab.

1162

    pub active_tab: usize,

1163

    /// Optional callback invoked when a tab is clicked.

1164

    pub on_click: OptionTabOnClick,

1165

1166

1167

impl Default for TabHeader {

1168

4

    fn default() -> Self {

1169

4

        Self {

1170

4

            tabs: StringVec::from_const_slice(&[]),

1171

4

            active_tab: 0,

1172

4

            on_click: None.into(),

1173

4

1174

4

1175

1176

1177

/// State passed to the tab-click callback, indicating which tab was selected.

1178

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

1179

#[repr(C)]

1180

pub struct TabHeaderState {

1181

    /// Zero-based index of the newly selected tab.

1182

    pub active_tab: usize,

1183

1184

1185

/// Signature for the tab-click callback function.

1186

pub type TabOnClickCallbackType = extern "C" fn(RefAny, CallbackInfo, TabHeaderState) -> Update;

1187

impl_widget_callback!(

1188

    TabOnClick,

1189

    OptionTabOnClick,

1190

    TabOnClickCallback,

1191

    TabOnClickCallbackType

1192

);

1193

1194

azul_core::impl_managed_callback! {

1195

    wrapper:        TabOnClickCallback,

1196

    info_ty:        CallbackInfo,

1197

    return_ty:      Update,

1198

    default_ret:    Update::DoNothing,

1199

    invoker_static: TAB_ON_CLICK_INVOKER,

1200

    invoker_ty:     AzTabOnClickCallbackInvoker,

1201

    thunk_fn:       az_tab_on_click_callback_thunk,

1202

    setter_fn:      AzApp_setTabOnClickCallbackInvoker,

1203

    from_handle_fn: AzTabOnClickCallback_createFromHostHandle,

1204

    extra_args:     [ state: TabHeaderState ],

1205

1206

1207

impl TabHeader {

1208

79

    #[must_use] pub fn create(tabs: StringVec) -> Self {

1209

79

        Self {

1210

79

            tabs,

1211

79

            active_tab: 0,

1212

79

            on_click: None.into(),

1213

79

1214

79

1215

1216

    #[must_use]

1217

4

    pub fn swap_with_default(&mut self) -> Self {

1218

4

        let mut default = Self::default();

1219

4

        core::mem::swap(&mut default, self);

1220

4

        default

1221

4

1222

1223

64

    pub const fn set_active_tab(&mut self, active_tab: usize) {

1224

64

        self.active_tab = active_tab;

1225

64

1226

1227

37

    #[must_use] pub const fn with_active_tab(mut self, active_tab: usize) -> Self {

1228

37

        self.set_active_tab(active_tab);

1229

37

        self

1230

37

1231

1232

14

    pub fn set_on_click<C: Into<TabOnClickCallback>>(&mut self, refany: RefAny, on_click: C) {

1233

14

        self.on_click = Some(TabOnClick {

1234

14

            refany,

1235

14

            callback: on_click.into(),

1236

14

})

1237

14

        .into();

1238

14

1239

1240

    #[must_use]

1241

7

    pub fn with_on_click<C: Into<TabOnClickCallback>>(

1242

7

        mut self,

1243

7

        refany: RefAny,

1244

7

        on_click: C,

1245

7

    ) -> Self {

1246

7

        self.set_on_click(refany, on_click);

1247

7

        self

1248

7

1249

1250

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

1251

50

    #[must_use] pub fn dom(self) -> Dom {

1252

        use azul_core::callbacks::CoreCallbackDataVec;

1253

1254

        // classes for previous tab

1255

        const IDS_AND_CLASSES_5117007530891373979: &[IdOrClass] = &[

1256

            Class(AzString::from_const_str(

1257

                "__azul-native-tabs-tab-norightborder",

1258

)),

1259

            Class(AzString::from_const_str(

1260

                "__azul-native-tabs-tab-not-active",

1261

)),

1262

        ]; // CSS_MATCH_4415083954137121609

1263

1264

        // classes for current tab

1265

        const IDS_AND_CLASSES_15002865554973741556: &[IdOrClass] = &[Class(

1266

            AzString::from_const_str("__azul-native-tabs-tab-active"),

1267

)];

1268

1269

        // classes for next tab

1270

        const IDS_AND_CLASSES_16877793354714897051: &[IdOrClass] = &[

1271

            Class(AzString::from_const_str(

1272

                "__azul-native-tabs-tab-noleftborder",

1273

)),

1274

            Class(AzString::from_const_str(

1275

                "__azul-native-tabs-tab-not-active",

1276

)),

1277

];

1278

1279

        // classes for default inactive tab

1280

        const IDS_AND_CLASSES_INACTIVE: &[IdOrClass] = &[Class(

1281

            AzString::from_const_str("__azul-native-tabs-tab-not-active"),

1282

)];

1283

1284

50

        let on_click_is_some = self.on_click.is_some();

1285

1286

50

        Dom::create_div()

1287

50

            .with_css_props(CSS_MATCH_9988039989460234263)

1288

50

            .with_ids_and_classes({

1289

                const IDS_AND_CLASSES_6172459441955124689: &[IdOrClass] =

1290

                    &[Class(AzString::from_const_str("__azul-native-tabs-header"))];

1291

50

                IdOrClassVec::from_const_slice(IDS_AND_CLASSES_6172459441955124689)

1292

})

1293

50

            .with_children({

1294

50

                let mut tab_items = vec![Dom::create_div()

1295

50

                    .with_css_props(CSS_MATCH_17290739305197504468)

1296

50

                    .with_ids_and_classes({

1297

                        const IDS_AND_CLASSES_8360971686689797550: &[IdOrClass] = &[Class(

1298

                            AzString::from_const_str("__azul-native-tabs-before-tabs"),

1299

)];

1300

50

                        IdOrClassVec::from_const_slice(IDS_AND_CLASSES_8360971686689797550)

1301

                    })];

1302

1303

50

                let dataset = TabLocalDataset {

1304

50

                    tab_idx: 0,

1305

50

                    on_click: self.on_click,

1306

50

};

1307

1308

1247

                for (tab_idx, tab) in self.tabs.as_ref().iter().enumerate() {

1309

1247

                    let next_tab_is_active = self.active_tab == tab_idx.saturating_add(1);

1310

1247

                    let previous_tab_was_active = if self.active_tab == 0 {

1311

1136

                        false

1312

                    } else {

1313

111

                        self.active_tab == tab_idx.saturating_sub(1)

1314

};

1315

1316

1247

                    let tab_is_active = self.active_tab == tab_idx;

1317

1318

1247

                    let (ids_and_classes, css_props) = if tab_is_active {

1319

36

1320

36

                            IDS_AND_CLASSES_15002865554973741556,

1321

36

                            CSS_MATCH_14575853790110873394,

1322

36

1323

1211

                    } else if next_tab_is_active {

1324

                        // tab before the active tab

1325

15

1326

15

                            IDS_AND_CLASSES_5117007530891373979,

1327

15

                            CSS_MATCH_4415083954137121609,

1328

15

1329

1196

                    } else if previous_tab_was_active {

1330

                        // tab after the active tab

1331

10

1332

10

                            IDS_AND_CLASSES_16877793354714897051,

1333

10

                            CSS_MATCH_13824480602841492081,

1334

10

1335

                    } else {

1336

                        // default inactive tab

1337

1186

                        (IDS_AND_CLASSES_INACTIVE, CSS_MATCH_11510695043643111367)

1338

};

1339

1340

1247

                    let mut dataset = dataset.clone();

1341

1247

                    dataset.tab_idx = tab_idx;

1342

1247

                    let dataset = RefAny::new(dataset);

1343

1344

1247

                    tab_items.push(

1345

1247

                        Dom::create_p_with_text(tab.clone())

1346

1247

                            .with_callbacks(if on_click_is_some {

1347

21

                                vec![CoreCallbackData {

1348

21

                                    event: EventFilter::Hover(HoverEventFilter::MouseUp),

1349

21

                                    callback: CoreCallback {

1350

21

                                        cb: on_tab_click as usize,

1351

21

                                        ctx: azul_core::refany::OptionRefAny::None,

1352

21

},

1353

21

                                    refany: dataset.clone(),

1354

21

}]

1355

21

                                .into()

1356

                            } else {

1357

1226

                                CoreCallbackDataVec::from_const_slice(&[])

1358

})

1359

1247

                            .with_dataset(Some(dataset).into())

1360

1247

                            .with_css_props(css_props)

1361

1247

                            .with_ids_and_classes(IdOrClassVec::from_const_slice(ids_and_classes)),

1362

);

1363

1364

1365

50

                tab_items.push(

1366

50

                    Dom::create_div()

1367

50

                        .with_css_props(CSS_MATCH_3088386549906605418)

1368

50

                        .with_ids_and_classes({

1369

                            const IDS_AND_CLASSES_11001585590816277275: &[IdOrClass] = &[Class(

1370

                                AzString::from_const_str("__azul-native-tabs-after-tabs"),

1371

)];

1372

50

                            IdOrClassVec::from_const_slice(IDS_AND_CLASSES_11001585590816277275)

1373

}),

1374

);

1375

1376

50

                tab_items.into()

1377

})

1378

50

1379

1380

1381

/// Content panel displayed beneath the active tab in a tab widget.

1382

#[derive(Debug, Clone)]

1383

#[repr(C)]

1384

pub struct TabContent {

1385

    /// The DOM subtree shown as the tab's content area.

1386

    pub content: Dom,

1387

    /// Whether the content area includes default padding.

1388

    pub has_padding: bool,

1389

1390

1391

impl Default for TabContent {

1392

2

    fn default() -> Self {

1393

2

        Self {

1394

2

            content: Dom::create_div(),

1395

2

            has_padding: true,

1396

2

1397

2

1398

1399

1400

impl TabContent {

1401

16

    #[must_use] pub const fn new(content: Dom) -> Self {

1402

16

        Self {

1403

16

            content,

1404

16

            has_padding: true,

1405

16

1406

16

1407

1408

    #[must_use]

1409

1

    pub fn swap_with_default(&mut self) -> Self {

1410

1

        let mut default = Self::default();

1411

1

        core::mem::swap(&mut default, self);

1412

1

        default

1413

1

1414

1415

8

    #[must_use] pub const fn with_padding(mut self, padding: bool) -> Self {

1416

8

        self.set_padding(padding);

1417

8

        self

1418

8

1419

1420

10

    pub const fn set_padding(&mut self, padding: bool) {

1421

10

        self.has_padding = padding;

1422

10

1423

1424

9

    #[must_use] pub fn dom(self) -> Dom {

1425

        const IDS_AND_CLASSES_2989815829020816222: &[IdOrClass] = &[Class(

1426

            AzString::from_const_str("__azul-native-tabs-content"),

1427

)];

1428

1429

9

        let tab_content_css_style = if self.has_padding {

1430

8

            CSS_MATCH_18014909903571752977

1431

        } else {

1432

1

            CSS_MATCH_18014909903571752977_NO_PADDING

1433

};

1434

1435

9

        Dom::create_div()

1436

9

            .with_css_props(tab_content_css_style)

1437

9

            .with_children(DomVec::from_vec(vec![Dom::create_div()

1438

9

                .with_ids_and_classes(IdOrClassVec::from_const_slice(

1439

                    IDS_AND_CLASSES_2989815829020816222,

1440

))

1441

9

                .with_children(DomVec::from_vec(vec![self.content]))]))

1442

9

1443

1444

1445

#[derive(Clone)]

1446

struct TabLocalDataset {

1447

    tab_idx: usize,

1448

    on_click: OptionTabOnClick,

1449

1450

1451

23

extern "C" fn on_tab_click(mut refany: RefAny, info: CallbackInfo) -> Update {

1452

23

    fn select_new_tab_inner(mut refany: RefAny, info: &CallbackInfo) -> Option<Update> {

1453

23

        let mut tab_local_dataset = refany.downcast_mut::<TabLocalDataset>()?;

1454

20

        let tab_idx = tab_local_dataset.tab_idx;

1455

20

        let tab_header_state = TabHeaderState {

1456

20

            active_tab: tab_idx,

1457

20

};

1458

1459

20

        let result = {

1460

            // rustc doesn't understand the borrowing lifetime here

1461

20

            let tab_local_dataset = &mut *tab_local_dataset;

1462

20

            let onclick = &mut tab_local_dataset.on_click;

1463

1464

20

            match onclick.as_mut() {

1465

18

                Some(TabOnClick { callback, refany }) => {

1466

18

                    (callback.cb)(refany.clone(), *info, tab_header_state)

1467

1468

2

                None => Update::DoNothing,

1469

1470

};

1471

1472

20

        Some(result)

1473

23

1474

1475

23

    select_new_tab_inner(refany, &info).unwrap_or(Update::RefreshDom)

1476

23

1477

1478

#[cfg(test)]

1479

mod autotest_generated {

1480

    use std::{

1481

        collections::BTreeMap,

1482

        sync::{Arc, Mutex},

1483

};

1484

1485

    use azul_core::{

1486

        dom::{DomId, DomNodeId, NodeId, NodeType},

1487

        geom::OptionLogicalPosition,

1488

        gl::OptionGlContextPtr,

1489

        hit_test::ScrollPosition,

1490

        refany::OptionRefAny,

1491

        resources::RendererResources,

1492

        styled_dom::{NodeHierarchyItemId, StyledDom},

1493

        window::{MonitorVec, RawWindowHandle},

1494

};

1495

    use azul_css::system::SystemStyle;

1496

    use rust_fontconfig::FcFontCache;

1497

1498

    use super::*;

1499

    #[cfg(feature = "icu")]

1500

    use crate::icu::IcuLocalizerHandle;

1501

    use crate::{

1502

        callbacks::{CallbackChange, CallbackInfoRefData, ExternalSystemCallbacks},

1503

        window::LayoutWindow,

1504

        window_state::FullWindowState,

1505

};

1506

1507

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

1508

    // Helpers

1509

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

1510

1511

    const CLASS_ACTIVE: &str = "__azul-native-tabs-tab-active";

1512

    const CLASS_NOT_ACTIVE: &str = "__azul-native-tabs-tab-not-active";

1513

    const CLASS_NO_LEFT: &str = "__azul-native-tabs-tab-noleftborder";

1514

    const CLASS_NO_RIGHT: &str = "__azul-native-tabs-tab-norightborder";

1515

    const CLASS_HEADER: &str = "__azul-native-tabs-header";

1516

    const CLASS_BEFORE: &str = "__azul-native-tabs-before-tabs";

1517

    const CLASS_AFTER: &str = "__azul-native-tabs-after-tabs";

1518

    const CLASS_CONTENT: &str = "__azul-native-tabs-content";

1519

1520

    fn strings(items: &[&str]) -> StringVec {

1521

        StringVec::from_vec(items.iter().map(|s| AzString::from(*s)).collect())

1522

1523

1524

    fn numbered_labels(n: usize) -> StringVec {

1525

        StringVec::from_vec((0..n).map(|i| AzString::from(format!("tab {i}"))).collect())

1526

1527

1528

    /// The text of a text node, looking through the `<p>` block wrapper the

1529

    /// label convention mandates (`p > text`).

1530

    fn text_of(node: &Dom) -> Option<&str> {

1531

        match node.root.get_node_type() {

1532

            NodeType::Text(s) => Some(s.as_ref().as_str()),

1533

            NodeType::P => match node.children.as_ref() {

1534

                [only] => match only.root.get_node_type() {

1535

                    NodeType::Text(s) => Some(s.as_ref().as_str()),

1536

                    _ => None,

1537

},

1538

                _ => None,

1539

},

1540

            _ => None,

1541

1542

1543

1544

    fn classes(node: &Dom) -> Vec<String> {

1545

        node.root

1546

            .get_ids_and_classes()

1547

            .as_ref()

1548

            .iter()

1549

            .filter_map(|c| match c {

1550

                Class(s) => Some(s.as_str().to_string()),

1551

                IdOrClass::Id(_) => None,

1552

})

1553

            .collect()

1554

1555

1556

    fn class_strs(node: &Dom) -> Vec<&'static str> {

1557

        // The widget only ever attaches the eight `&'static str` classes above;

1558

        // map back to them so the tests can compare against string literals.

1559

        classes(node)

1560

            .into_iter()

1561

            .map(|c| {

1562

1563

                    CLASS_ACTIVE,

1564

                    CLASS_NOT_ACTIVE,

1565

                    CLASS_NO_LEFT,

1566

                    CLASS_NO_RIGHT,

1567

                    CLASS_HEADER,

1568

                    CLASS_BEFORE,

1569

                    CLASS_AFTER,

1570

                    CLASS_CONTENT,

1571

1572

                .into_iter()

1573

                .find(|known| *known == c)

1574

                .unwrap_or_else(|| panic!("tabs.rs emitted an unknown class: {c}"))

1575

})

1576

            .collect()

1577

1578

1579

    /// A style vec as `(property, condition-count)` pairs in declaration order —

1580

    /// the exact shape `Css::from(CssPropertyWithConditionsVec)` preserves.

1581

    fn declared(v: &CssPropertyWithConditionsVec) -> Vec<(CssProperty, usize)> {

1582

        v.as_ref()

1583

            .iter()

1584

            .map(|p| (p.property.clone(), p.apply_if.as_ref().len()))

1585

            .collect()

1586

1587

1588

    /// The same view, read back off a rendered node's inline `Css`.

1589

    fn inline_declared(node: &Dom) -> Vec<(CssProperty, usize)> {

1590

        node.root

1591

            .style

1592

            .iter_inline_properties()

1593

            .map(|(p, conds)| (p.clone(), conds.as_ref().len()))

1594

            .collect()

1595

1596

1597

    /// Every declaration in `v` matching `pred`, in declaration order.

1598

    fn decls_where(

1599

        v: &CssPropertyWithConditionsVec,

1600

        pred: fn(&CssProperty) -> bool,

1601

    ) -> Vec<CssProperty> {

1602

        v.as_ref()

1603

            .iter()

1604

            .filter(|p| pred(&p.property))

1605

            .map(|p| p.property.clone())

1606

            .collect()

1607

1608

1609

    /// Same, but skipping the `:hover` block — these styles declare the border

1610

    /// properties once for hover and again unconditionally, so a raw filter would

1611

    /// mix the two sets.

1612

    fn plain_decls_where(

1613

        v: &CssPropertyWithConditionsVec,

1614

        pred: fn(&CssProperty) -> bool,

1615

    ) -> Vec<CssProperty> {

1616

        v.as_ref()

1617

            .iter()

1618

            .filter(|p| p.apply_if.as_ref().is_empty() && pred(&p.property))

1619

            .map(|p| p.property.clone())

1620

            .collect()

1621

1622

1623

    /// The style vec the widget must pair with a given class combination.

1624

    fn style_for_classes(cls: &[&str]) -> CssPropertyWithConditionsVec {

1625

        let cls = cls.to_vec();

1626

        if cls == [CLASS_ACTIVE] {

1627

            CSS_MATCH_14575853790110873394

1628

        } else if cls == [CLASS_NO_RIGHT, CLASS_NOT_ACTIVE] {

1629

            CSS_MATCH_4415083954137121609

1630

        } else if cls == [CLASS_NO_LEFT, CLASS_NOT_ACTIVE] {

1631

            CSS_MATCH_13824480602841492081

1632

        } else if cls == [CLASS_NOT_ACTIVE] {

1633

            CSS_MATCH_11510695043643111367

1634

        } else {

1635

            panic!("unexpected class combination on a tab node: {cls:?}");

1636

1637

1638

1639

    /// The dataset `RefAny` a rendered tab node carries (cloned, so the caller

1640

    /// can `downcast_*` it without borrowing the Dom mutably).

1641

    fn dataset_of(node: &Dom) -> RefAny {

1642

        node.root

1643

            .get_dataset()

1644

            .expect("every tab node carries a TabLocalDataset")

1645

            .clone()

1646

1647

1648

    fn tab_idx_of(node: &Dom) -> usize {

1649

        let mut ds = dataset_of(node);

1650

        let tab_idx = ds

1651

            .downcast_ref::<TabLocalDataset>()

1652

            .expect("the dataset must be a TabLocalDataset")

1653

            .tab_idx;

1654

        tab_idx

1655

1656

1657

    /// A `RefAny` payload recording every state a user `on_click` observes.

1658

    #[derive(Default)]

1659

    struct ClickLog {

1660

        seen: Vec<TabHeaderState>,

1661

1662

1663

    extern "C" fn record_click(

1664

        mut refany: RefAny,

1665

        _: CallbackInfo,

1666

        state: TabHeaderState,

1667

    ) -> Update {

1668

        if let Some(mut log) = refany.downcast_mut::<ClickLog>() {

1669

            log.seen.push(state);

1670

1671

        Update::RefreshDom

1672

1673

1674

    extern "C" fn click_do_nothing(_: RefAny, _: CallbackInfo, _: TabHeaderState) -> Update {

1675

        Update::DoNothing

1676

1677

1678

    extern "C" fn click_refresh_all(_: RefAny, _: CallbackInfo, _: TabHeaderState) -> Update {

1679

        Update::RefreshDomAllWindows

1680

1681

1682

    /// Forces the `fn`-item -> `fn`-pointer coercion the `Into` bound needs.

1683

    fn cb(f: TabOnClickCallbackType) -> TabOnClickCallback {

1684

        f.into()

1685

1686

1687

    fn logged(refany: &mut RefAny) -> Vec<TabHeaderState> {

1688

        refany

1689

            .downcast_ref::<ClickLog>()

1690

            .expect("payload must still be a ClickLog")

1691

            .seen

1692

            .clone()

1693

1694

1695

    fn dataset(tab_idx: usize, on_click: OptionTabOnClick) -> RefAny {

1696

        RefAny::new(TabLocalDataset { tab_idx, on_click })

1697

1698

1699

    fn click_handler(refany: RefAny, callback: TabOnClickCallbackType) -> OptionTabOnClick {

1700

        Some(TabOnClick {

1701

            refany,

1702

            callback: cb(callback),

1703

})

1704

        .into()

1705

1706

1707

    /// Invokes `on_tab_click` with a minimal `CallbackInfo` (the handler never

1708

    /// touches the layout window — it only downcasts its own dataset — so an

1709

    /// empty `LayoutWindow` and node 0 as the hit node are enough).

1710

    /// Returns the `Update` plus every recorded `CallbackChange`.

1711

    fn run_click(data: RefAny) -> (Update, Vec<CallbackChange>) {

1712

        let layout_window =

1713

            LayoutWindow::new(FcFontCache::default()).expect("LayoutWindow::new failed");

1714

1715

        let renderer_resources = RendererResources::default();

1716

        let previous_window_state: Option<FullWindowState> = None;

1717

        let current_window_state = FullWindowState::default();

1718

        let gl_context = OptionGlContextPtr::None;

1719

        let scroll_states: BTreeMap<DomId, BTreeMap<NodeHierarchyItemId, ScrollPosition>> =

1720

            BTreeMap::new();

1721

        let window_handle = RawWindowHandle::Unsupported;

1722

        let system_callbacks = ExternalSystemCallbacks::rust_internal();

1723

1724

        let ref_data = CallbackInfoRefData {

1725

            layout_window: &layout_window,

1726

            renderer_resources: &renderer_resources,

1727

            previous_window_state: &previous_window_state,

1728

            current_window_state: &current_window_state,

1729

            gl_context: &gl_context,

1730

            current_scroll_manager: &scroll_states,

1731

            current_window_handle: &window_handle,

1732

            system_callbacks: &system_callbacks,

1733

            system_style: Arc::new(SystemStyle::default()),

1734

            monitors: Arc::new(Mutex::new(MonitorVec::from_const_slice(&[]))),

1735

            #[cfg(feature = "icu")]

1736

            icu_localizer: IcuLocalizerHandle::default(),

1737

            ctx: OptionRefAny::None,

1738

};

1739

1740

        let changes: Arc<Mutex<Vec<CallbackChange>>> = Arc::new(Mutex::new(Vec::new()));

1741

1742

        let info = CallbackInfo::new(

1743

            &ref_data,

1744

            &changes,

1745

            DomNodeId {

1746

                dom: DomId::ROOT_ID,

1747

                node: NodeHierarchyItemId::from_crate_internal(Some(NodeId::new(0))),

1748

},

1749

            OptionLogicalPosition::None,

1750

            OptionLogicalPosition::None,

1751

);

1752

1753

        let update = on_tab_click(data, info);

1754

        let recorded = core::mem::take(&mut *changes.lock().expect("change log poisoned"));

1755

        (update, recorded)

1756

1757

1758

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

1759

    // TabHeader::create

1760

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

1761

1762

    #[test]

1763

    fn create_keeps_the_label_vec_verbatim_and_starts_inert() {

1764

        for labels in [

1765

            strings(&[]),

1766

            strings(&["only"]),

1767

            strings(&["a", "b", "c"]),

1768

            numbered_labels(1000),

1769

] {

1770

            let expected: Vec<AzString> = labels.as_ref().to_vec();

1771

            let header = TabHeader::create(labels);

1772

1773

            assert_eq!(

1774

                header.tabs.as_ref(),

1775

                expected.as_slice(),

1776

                "create must not reorder, drop or rewrite labels"

1777

);

1778

            assert_eq!(header.active_tab, 0, "a fresh header selects the first tab");

1779

            assert!(

1780

                header.on_click.is_none(),

1781

                "create must not install a callback"

1782

);

1783

1784

1785

1786

    #[test]

1787

    fn create_accepts_an_empty_label_vec_and_still_renders_the_spacers() {

1788

        // Zero tabs is the degenerate case: the loop body never runs, but the

1789

        // before/after spacers must still be emitted or the header collapses.

1790

        let dom = TabHeader::create(strings(&[])).dom();

1791

        let children = dom.children.as_ref();

1792

1793

        assert_eq!(children.len(), 2, "an empty header is just the two spacers");

1794

        assert_eq!(class_strs(&children[0]), vec![CLASS_BEFORE]);

1795

        assert_eq!(class_strs(&children[1]), vec![CLASS_AFTER]);

1796

1797

1798

    #[test]

1799

    fn create_round_trips_pathological_labels_through_the_dom() {

1800

        // The label is only ever cloned into a `NodeType::Text`, never parsed,

1801

        // trimmed or NUL-terminated — so every byte must survive verbatim.

1802

        let long = "\u{e9}".repeat(50_000);

1803

        let pathological: Vec<String> = vec![

1804

            String::new(),

1805

            " ".to_string(),

1806

            "\0embedded\0nul\0".to_string(),

1807

            "\u{1F600}\u{1F3F4}\u{E0067}\u{E007F}".to_string(), // emoji + tag sequence

1808

            "a\u{0301}\u{0327}\u{0328}".to_string(),            // stacked combining marks

1809

            "\u{202E}reversed\u{202C}".to_string(),             // RTL override

1810

            "\r\n\t".to_string(),

1811

            "\u{FFFD}\u{FEFF}".to_string(), // replacement char + BOM

1812

            long.clone(),

1813

];

1814

1815

        let labels = StringVec::from_vec(

1816

            pathological

1817

                .iter()

1818

                .map(|s| AzString::from(s.clone()))

1819

                .collect(),

1820

);

1821

        let dom = TabHeader::create(labels).dom();

1822

        let children = dom.children.as_ref();

1823

1824

        assert_eq!(children.len(), pathological.len() + 2);

1825

        for (i, expected) in pathological.iter().enumerate() {

1826

            assert_eq!(

1827

                text_of(&children[i + 1]),

1828

                Some(expected.as_str()),

1829

                "label {i} did not round-trip through the DOM"

1830

);

1831

1832

1833

1834

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

1835

    // TabHeader::set_active_tab / with_active_tab  (numeric)

1836

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

1837

1838

    #[test]

1839

    fn set_active_tab_stores_any_usize_without_clamping_or_panicking() {

1840

        // `active_tab` is an unsigned index with no documented upper bound and

1841

        // no relation to `tabs.len()` — there is no signed path to test, so the

1842

        // adversarial values are 0, the wrap-around of 0 and the two extremes.

1843

        let extremes = [

1844

            0usize,

1845

1,

1846

2,

1847

            usize::MAX / 2,

1848

            usize::MAX - 1,

1849

            usize::MAX,

1850

            0usize.wrapping_sub(1),

1851

];

1852

1853

        for value in extremes {

1854

            let mut header = TabHeader::create(strings(&["a", "b", "c"]));

1855

            header.set_active_tab(value);

1856

            assert_eq!(

1857

                header.active_tab, value,

1858

                "set_active_tab must store the index verbatim (no clamp to len)"

1859

);

1860

1861

            // Idempotent + last-write-wins.

1862

            header.set_active_tab(value);

1863

            assert_eq!(header.active_tab, value);

1864

            header.set_active_tab(0);

1865

            assert_eq!(header.active_tab, 0, "the last write must win");

1866

1867

1868

1869

    #[test]

1870

    fn set_active_tab_touches_nothing_but_the_index() {

1871

        let mut header = TabHeader::create(strings(&["a", "b"]));

1872

        header.set_on_click(RefAny::new(ClickLog::default()), cb(record_click));

1873

1874

        header.set_active_tab(usize::MAX);

1875

1876

        assert_eq!(

1877

            header.tabs.as_ref(),

1878

            strings(&["a", "b"]).as_ref(),

1879

            "the labels must be untouched"

1880

);

1881

        assert!(

1882

            header.on_click.is_some(),

1883

            "the callback must survive a selection change"

1884

);

1885

1886

1887

    #[test]

1888

    fn with_active_tab_agrees_with_set_active_tab_at_every_extreme() {

1889

        for value in [0usize, 1, usize::MAX / 2, usize::MAX - 1, usize::MAX] {

1890

            let built = TabHeader::create(strings(&["a", "b"])).with_active_tab(value);

1891

            let mut mutated = TabHeader::create(strings(&["a", "b"]));

1892

            mutated.set_active_tab(value);

1893

1894

            assert_eq!(built.active_tab, mutated.active_tab);

1895

            assert_eq!(built.active_tab, value);

1896

            assert_eq!(built.tabs.as_ref(), mutated.tabs.as_ref());

1897

            assert!(built.on_click.is_none() && mutated.on_click.is_none());

1898

1899

1900

1901

    #[test]

1902

    fn with_active_tab_chains_last_wins() {

1903

        let header = TabHeader::create(strings(&["a"]))

1904

            .with_active_tab(usize::MAX)

1905

            .with_active_tab(7)

1906

            .with_active_tab(0);

1907

        assert_eq!(header.active_tab, 0);

1908

1909

1910

    #[test]

1911

    fn dom_never_marks_a_tab_active_when_the_index_is_out_of_range() {

1912

        // An out-of-range selection must degrade to "nothing selected" rather

1913

        // than panicking or wrapping onto some other tab.

1914

        let n = 4usize;

1915

        for active in [n, n + 1, n + 2, usize::MAX / 2, usize::MAX - 1, usize::MAX] {

1916

            let dom = TabHeader::create(numbered_labels(n))

1917

                .with_active_tab(active)

1918

                .dom();

1919

            let children = dom.children.as_ref();

1920

            assert_eq!(children.len(), n + 2, "active={active}: wrong child count");

1921

1922

            for (i, node) in children[1..=n].iter().enumerate() {

1923

                let cls = class_strs(node);

1924

                assert!(

1925

                    !cls.contains(&CLASS_ACTIVE),

1926

                    "active={active}: tab {i} must not be styled active"

1927

);

1928

                assert!(

1929

                    cls.contains(&CLASS_NOT_ACTIVE),

1930

                    "active={active}: tab {i} must be styled inactive"

1931

);

1932

1933

1934

1935

1936

    #[test]

1937

    fn dom_at_usize_max_gives_every_tab_the_plain_inactive_style() {

1938

        // `tab_idx.saturating_add(1)` / `saturating_sub(1)` must not wrap into a

1939

        // false neighbour match at the extreme.

1940

        let n = 5usize;

1941

        let dom = TabHeader::create(numbered_labels(n))

1942

            .with_active_tab(usize::MAX)

1943

            .dom();

1944

1945

        for (i, node) in dom.children.as_ref()[1..=n].iter().enumerate() {

1946

            assert_eq!(

1947

                class_strs(node),

1948

                vec![CLASS_NOT_ACTIVE],

1949

                "tab {i} must carry the plain inactive class only"

1950

);

1951

            assert_eq!(

1952

                inline_declared(node),

1953

                declared(&CSS_MATCH_11510695043643111367),

1954

                "tab {i} must carry the plain inactive style"

1955

);

1956

1957

1958

1959

    #[test]

1960

    fn dom_one_past_the_end_still_seams_the_last_tab() {

1961

        // PINNED QUIRK: with `active_tab == tabs.len()` no tab is active, yet the

1962

        // *last* tab still matches `active_tab == tab_idx + 1` and loses its right

1963

        // border — a visible seam against the after-tabs spacer. Deliberately

1964

        // pinned: if the widget starts range-checking `active_tab`, this flips.

1965

        let n = 3usize;

1966

        let dom = TabHeader::create(numbered_labels(n)).with_active_tab(n).dom();

1967

        let children = dom.children.as_ref();

1968

1969

        assert_eq!(

1970

            class_strs(&children[n]),

1971

            vec![CLASS_NO_RIGHT, CLASS_NOT_ACTIVE],

1972

            "the last tab is styled as if the (non-existent) next tab were active"

1973

);

1974

        for (i, node) in children[1..n].iter().enumerate() {

1975

            assert_eq!(class_strs(node), vec![CLASS_NOT_ACTIVE], "tab {i}");

1976

1977

1978

1979

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

1980

    // TabHeader::swap_with_default

1981

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

1982

1983

    #[test]

1984

    fn swap_with_default_moves_the_state_out_and_leaves_a_default() {

1985

        let mut header = TabHeader::create(strings(&["a", "b", "c"])).with_active_tab(2);

1986

        header.set_on_click(RefAny::new(ClickLog::default()), cb(record_click));

1987

1988

        let taken = header.swap_with_default();

1989

1990

        assert_eq!(taken.tabs.as_ref(), strings(&["a", "b", "c"]).as_ref());

1991

        assert_eq!(taken.active_tab, 2);

1992

        assert!(taken.on_click.is_some(), "the callback moves out with the state");

1993

1994

        assert!(header.tabs.as_ref().is_empty(), "the husk must have no tabs");

1995

        assert_eq!(header.active_tab, 0);

1996

        assert!(

1997

            header.on_click.is_none(),

1998

            "the husk must not keep a live callback"

1999

);

2000

2001

2002

    #[test]

2003

    fn swap_with_default_twice_yields_a_default_the_second_time() {

2004

        let mut header = TabHeader::create(strings(&["a"])).with_active_tab(usize::MAX);

2005

        let first = header.swap_with_default();

2006

        let second = header.swap_with_default();

2007

2008

        assert_eq!(first.active_tab, usize::MAX);

2009

        assert_eq!(first.tabs.as_ref().len(), 1);

2010

        assert_eq!(second.active_tab, 0);

2011

        assert!(second.tabs.as_ref().is_empty());

2012

2013

2014

    #[test]

2015

    fn swap_with_default_releases_the_callback_payload_when_dropped() {

2016

        let user = RefAny::new(ClickLog::default());

2017

        let mut header = TabHeader::create(strings(&["a"]));

2018

        header.set_on_click(user.clone(), cb(record_click));

2019

        assert_eq!(user.get_ref_count(), 2);

2020

2021

        drop(header.swap_with_default());

2022

        assert_eq!(

2023

            user.get_ref_count(),

2024

1,

2025

            "the swapped-out header must drop its payload clone"

2026

);

2027

2028

2029

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

2030

    // TabHeader::set_on_click / with_on_click

2031

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

2032

2033

    #[test]

2034

    fn with_on_click_installs_the_callback_and_touches_nothing_else() {

2035

        let before = TabHeader::create(strings(&["a", "b"])).with_active_tab(1);

2036

        let mut after = TabHeader::create(strings(&["a", "b"]))

2037

            .with_active_tab(1)

2038

            .with_on_click(RefAny::new(ClickLog::default()), cb(record_click));

2039

2040

        assert_eq!(after.tabs.as_ref(), before.tabs.as_ref());

2041

        assert_eq!(after.active_tab, before.active_tab);

2042

2043

        let installed = after

2044

            .on_click

2045

            .as_mut()

2046

            .expect("with_on_click must install Some(..)");

2047

        assert_eq!(installed.callback.cb as usize, record_click as usize);

2048

        assert!(

2049

            installed.refany.downcast_ref::<ClickLog>().is_some(),

2050

            "the payload must be stored as handed in"

2051

);

2052

2053

2054

    #[test]

2055

    fn set_on_click_overwrites_the_previous_callback_and_payload() {

2056

        let mut header = TabHeader::create(strings(&["a"]));

2057

        header.set_on_click(RefAny::new(ClickLog::default()), cb(record_click));

2058

        header.set_on_click(RefAny::new(42u32), cb(click_do_nothing));

2059

2060

        let installed = header.on_click.as_mut().expect("still Some after overwrite");

2061

        assert_eq!(

2062

            installed.callback.cb as usize,

2063

            click_do_nothing as usize,

2064

            "the last set_on_click must win"

2065

);

2066

        assert_eq!(

2067

            installed.refany.downcast_ref::<u32>().map(|v| *v),

2068

            Some(42),

2069

            "the payload must be replaced together with the fn pointer"

2070

);

2071

        assert!(

2072

            installed.refany.downcast_ref::<ClickLog>().is_none(),

2073

            "the stale payload must be gone"

2074

);

2075

2076

2077

    #[test]

2078

    fn set_on_click_drops_the_previous_payload() {

2079

        let first = RefAny::new(ClickLog::default());

2080

        let second = RefAny::new(ClickLog::default());

2081

        let mut header = TabHeader::create(strings(&["a"]));

2082

2083

        header.set_on_click(first.clone(), cb(record_click));

2084

        assert_eq!(first.get_ref_count(), 2);

2085

        header.set_on_click(second.clone(), cb(record_click));

2086

2087

        assert_eq!(

2088

            first.get_ref_count(),

2089

1,

2090

            "overwriting the callback must release the old payload"

2091

);

2092

        assert_eq!(second.get_ref_count(), 2);

2093

2094

2095

    #[test]

2096

    fn generic_callback_conversion_round_trips_the_fn_pointer() {

2097

        // The FFI path (`From<Callback>`) transmutes the fn pointer; a corrupted

2098

        // value would be an unconditional jump into garbage at click time.

2099

        // (Never invoked here.)

2100

        let raw = record_click as usize;

2101

        let generic = Callback {

2102

            cb: unsafe { core::mem::transmute::<usize, crate::callbacks::CallbackType>(raw) },

2103

            ctx: OptionRefAny::None,

2104

};

2105

        let converted: TabOnClickCallback = generic.into();

2106

        assert_eq!(converted.cb as usize, raw);

2107

2108

2109

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

2110

    // TabHeader::dom — structure

2111

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

2112

2113

    #[test]

2114

    fn dom_is_a_header_div_wrapping_spacer_tabs_spacer() {

2115

        for n in [0usize, 1, 2, 3, 17] {

2116

            let dom = TabHeader::create(numbered_labels(n)).dom();

2117

2118

            assert_eq!(class_strs(&dom), vec![CLASS_HEADER]);

2119

            assert_eq!(inline_declared(&dom), declared(&CSS_MATCH_9988039989460234263));

2120

            assert!(

2121

                matches!(dom.root.get_node_type(), NodeType::Div),

2122

                "the header itself is a plain div"

2123

);

2124

2125

            let children = dom.children.as_ref();

2126

            assert_eq!(children.len(), n + 2, "n={n}: spacer + {n} tabs + spacer");

2127

2128

            assert_eq!(class_strs(&children[0]), vec![CLASS_BEFORE]);

2129

            assert_eq!(

2130

                inline_declared(&children[0]),

2131

                declared(&CSS_MATCH_17290739305197504468)

2132

);

2133

            assert_eq!(class_strs(&children[n + 1]), vec![CLASS_AFTER]);

2134

            assert_eq!(

2135

                inline_declared(&children[n + 1]),

2136

                declared(&CSS_MATCH_3088386549906605418)

2137

);

2138

2139

            for (i, node) in children[1..=n].iter().enumerate() {

2140

                assert_eq!(

2141

                    text_of(node),

2142

                    Some(format!("tab {i}").as_str()),

2143

                    "n={n}: tab {i} sits at sibling position {}",

2144

                    i + 1

2145

);

2146

2147

2148

2149

2150

    #[test]

2151

    fn dom_marks_exactly_one_tab_active_for_every_in_range_index() {

2152

        let n = 6usize;

2153

        for active in 0..n {

2154

            let dom = TabHeader::create(numbered_labels(n))

2155

                .with_active_tab(active)

2156

                .dom();

2157

            let children = dom.children.as_ref();

2158

2159

            let active_nodes: Vec<usize> = children[1..=n]

2160

                .iter()

2161

                .enumerate()

2162

                .filter(|(_, node)| class_strs(node).contains(&CLASS_ACTIVE))

2163

                .map(|(i, _)| i)

2164

                .collect();

2165

            assert_eq!(

2166

                active_nodes,

2167

                vec![active],

2168

                "exactly the selected tab must carry the active class"

2169

);

2170

2171

            for (i, node) in children[1..=n].iter().enumerate() {

2172

                let cls = class_strs(node);

2173

                assert_eq!(

2174

                    cls.contains(&CLASS_ACTIVE),

2175

                    !cls.contains(&CLASS_NOT_ACTIVE),

2176

                    "active={active}, tab {i}: active/not-active must be exclusive"

2177

);

2178

                assert!(

2179

                    !(cls.contains(&CLASS_NO_LEFT) && cls.contains(&CLASS_NO_RIGHT)),

2180

                    "active={active}, tab {i}: a tab cannot drop both side borders"

2181

);

2182

                assert!(

2183

                    !(cls.contains(&CLASS_ACTIVE)

2184

                        && (cls.contains(&CLASS_NO_LEFT) || cls.contains(&CLASS_NO_RIGHT))),

2185

                    "active={active}, tab {i}: the active tab keeps both side borders"

2186

);

2187

2188

2189

2190

2191

    #[test]

2192

    fn dom_gives_the_neighbours_of_the_active_tab_their_seam_classes() {

2193

        // active = 2 of 5: tab 1 loses its right border, tab 3 its left one.

2194

        let dom = TabHeader::create(numbered_labels(5)).with_active_tab(2).dom();

2195

        let children = dom.children.as_ref();

2196

2197

        assert_eq!(class_strs(&children[1]), vec![CLASS_NOT_ACTIVE], "tab 0");

2198

        assert_eq!(

2199

            class_strs(&children[2]),

2200

            vec![CLASS_NO_RIGHT, CLASS_NOT_ACTIVE],

2201

            "tab 1 sits before the active tab"

2202

);

2203

        assert_eq!(class_strs(&children[3]), vec![CLASS_ACTIVE], "tab 2");

2204

        assert_eq!(

2205

            class_strs(&children[4]),

2206

            vec![CLASS_NO_LEFT, CLASS_NOT_ACTIVE],

2207

            "tab 3 sits after the active tab"

2208

);

2209

        assert_eq!(class_strs(&children[5]), vec![CLASS_NOT_ACTIVE], "tab 4");

2210

2211

2212

    #[test]

2213

    fn dom_first_tab_active_leaves_the_second_tab_with_a_left_border() {

2214

        // PINNED BUG: `previous_tab_was_active` short-circuits on

2215

        // `self.active_tab == 0`, so for the *default* selection (tab 0) the tab

2216

        // right after the active one never gets `-noleftborder` — it draws a left

2217

        // border straight against the active tab's right edge. Every other

2218

        // selection (see the test above) does emit the class. Pinned as-is so the

2219

        // fix flips this test loudly.

2220

        let dom = TabHeader::create(numbered_labels(4)).with_active_tab(0).dom();

2221

        let children = dom.children.as_ref();

2222

2223

        assert_eq!(class_strs(&children[1]), vec![CLASS_ACTIVE], "tab 0");

2224

        assert_eq!(

2225

            class_strs(&children[2]),

2226

            vec![CLASS_NOT_ACTIVE],

2227

            "tab 1 should be [-noleftborder, -not-active] like the active=1..n case"

2228

);

2229

        assert_eq!(class_strs(&children[3]), vec![CLASS_NOT_ACTIVE], "tab 2");

2230

2231

        // The symmetric neighbour (active = 1) *does* get the class, which is what

2232

        // makes the case above an inconsistency rather than a design choice.

2233

        let dom = TabHeader::create(numbered_labels(4)).with_active_tab(1).dom();

2234

        assert_eq!(

2235

            class_strs(&dom.children.as_ref()[3]),

2236

            vec![CLASS_NO_LEFT, CLASS_NOT_ACTIVE],

2237

            "tab 2 after active tab 1"

2238

);

2239

2240

2241

    #[test]

2242

    fn dom_pairs_every_tab_style_with_the_classes_it_advertises() {

2243

        // A swapped class/style pair (e.g. the "noleftborder" node getting the

2244

        // style that nulls the *right* border) would be invisible in a class-only

2245

        // check, so compare the rendered inline style against the vec the class

2246

        // combination demands.

2247

        let n = 6usize;

2248

        for active in [0usize, 1, 2, n - 1, n, usize::MAX] {

2249

            let dom = TabHeader::create(numbered_labels(n))

2250

                .with_active_tab(active)

2251

                .dom();

2252

            for (i, node) in dom.children.as_ref()[1..=n].iter().enumerate() {

2253

                let cls = class_strs(node);

2254

                assert_eq!(

2255

                    inline_declared(node),

2256

                    declared(&style_for_classes(&cls)),

2257

                    "active={active}, tab {i}: style does not match classes {cls:?}"

2258

);

2259

2260

2261

2262

2263

    #[test]

2264

    fn neighbour_styles_null_the_border_on_the_side_their_class_names_claim() {

2265

        let no_left = plain_decls_where(&CSS_MATCH_13824480602841492081, |p| {

2266

            matches!(p, CssProperty::BorderLeftWidth(_))

2267

});

2268

        let no_right = plain_decls_where(&CSS_MATCH_4415083954137121609, |p| {

2269

            matches!(p, CssProperty::BorderRightWidth(_))

2270

});

2271

2272

        assert_eq!(

2273

            no_left.first(),

2274

            Some(&CssProperty::BorderLeftWidth(

2275

                LayoutBorderLeftWidthValue::None

2276

)),

2277

            "the -noleftborder style must null the LEFT border first"

2278

);

2279

        assert_eq!(

2280

            no_right.first(),

2281

            Some(&CssProperty::BorderRightWidth(

2282

                LayoutBorderRightWidthValue::None

2283

)),

2284

            "the -norightborder style must null the RIGHT border first"

2285

);

2286

2287

        // ...and must not null the opposite side.

2288

        assert!(

2289

            !decls_where(&CSS_MATCH_13824480602841492081, |p| matches!(

2290

p,

2291

                CssProperty::BorderRightWidth(_)

2292

))

2293

            .contains(&CssProperty::BorderRightWidth(

2294

                LayoutBorderRightWidthValue::None

2295

)),

2296

            "the -noleftborder style must keep the right border"

2297

);

2298

        assert!(

2299

            !decls_where(&CSS_MATCH_4415083954137121609, |p| matches!(

2300

p,

2301

                CssProperty::BorderLeftWidth(_)

2302

))

2303

            .contains(&CssProperty::BorderLeftWidth(

2304

                LayoutBorderLeftWidthValue::None

2305

)),

2306

            "the -norightborder style must keep the left border"

2307

);

2308

2309

        // The plain inactive style (no active neighbour) keeps both side borders:

2310

        // exactly one unconditional declaration per side, and neither is `None`.

2311

        let plain_left = plain_decls_where(&CSS_MATCH_11510695043643111367, |p| {

2312

            matches!(p, CssProperty::BorderLeftWidth(_))

2313

});

2314

        let plain_right = plain_decls_where(&CSS_MATCH_11510695043643111367, |p| {

2315

            matches!(p, CssProperty::BorderRightWidth(_))

2316

});

2317

        assert_eq!(plain_left.len(), 1, "one unconditional left-border width");

2318

        assert_eq!(plain_right.len(), 1, "one unconditional right-border width");

2319

        assert_ne!(

2320

            plain_left[0],

2321

            CssProperty::BorderLeftWidth(LayoutBorderLeftWidthValue::None),

2322

            "a tab with no active neighbour keeps its left border"

2323

);

2324

        assert_ne!(

2325

            plain_right[0],

2326

            CssProperty::BorderRightWidth(LayoutBorderRightWidthValue::None),

2327

            "a tab with no active neighbour keeps its right border"

2328

);

2329

2330

2331

    #[test]

2332

    fn tab_styles_redeclare_properties_and_therefore_depend_on_declaration_order() {

2333

        // PINNED HAZARD: each vec is emitted most-specific-block-first, so the

2334

        // generic `.__azul-native-tabs-header p` block *repeats* properties the

2335

        // state-specific block already set, with different values. Which one wins

2336

        // is decided by the resolver, and the two in azul disagree:

2337

        // `PropertyCache::get_property` takes the FIRST match (specific wins,

2338

        // intended), `get_property_with_context` takes the LAST ("last wins",

2339

        // which silently repaints the active tab like an inactive one).

2340

        let heights = decls_where(&CSS_MATCH_14575853790110873394, |p| {

2341

            matches!(p, CssProperty::Height(_))

2342

});

2343

        assert_eq!(heights.len(), 2, "the active tab declares height twice");

2344

        assert_eq!(

2345

            heights[0],

2346

            CssProperty::Height(LayoutHeightValue::Exact(LayoutHeight::Px(

2347

                PixelValue::const_px(23)

2348

            ))),

2349

            "the active-tab block (23px) must come first"

2350

);

2351

        assert_eq!(

2352

            heights[1],

2353

            CssProperty::Height(LayoutHeightValue::Exact(LayoutHeight::Px(

2354

                PixelValue::const_px(21)

2355

            ))),

2356

            "the generic p block (21px) shadows it under last-wins"

2357

);

2358

2359

        let backgrounds = decls_where(&CSS_MATCH_14575853790110873394, |p| {

2360

            matches!(p, CssProperty::BackgroundContent(_))

2361

});

2362

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

2363

        let kind = |p: &CssProperty| -> &'static str {

2364

            let CssProperty::BackgroundContent(v) = p else {

2365

                unreachable!()

2366

};

2367

            match v

2368

                .get_property()

2369

                .expect("an exact background")

2370

                .as_ref()

2371

                .first()

2372

                .expect("one layer")

2373

2374

                StyleBackgroundContent::Color(_) => "flat",

2375

                StyleBackgroundContent::LinearGradient(_) => "gradient",

2376

                _ => "other",

2377

2378

};

2379

        assert_eq!(kind(&backgrounds[0]), "flat", "active = white fill");

2380

        assert_eq!(

2381

            kind(&backgrounds[1]),

2382

            "gradient",

2383

            "the generic p block re-declares the inactive gradient"

2384

);

2385

2386

        // Same shape on the seam styles: the None triple is re-declared as 1px.

2387

        let left = plain_decls_where(&CSS_MATCH_13824480602841492081, |p| {

2388

            matches!(p, CssProperty::BorderLeftWidth(_))

2389

});

2390

        assert_eq!(left.len(), 2, "the -noleftborder style declares it twice");

2391

        assert_eq!(left[0], CssProperty::BorderLeftWidth(LayoutBorderLeftWidthValue::None));

2392

        assert_eq!(

2393

            left[1],

2394

            CssProperty::BorderLeftWidth(LayoutBorderLeftWidthValue::Exact(

2395

                LayoutBorderLeftWidth {

2396

                    inner: PixelValue::const_px(1)

2397

2398

))

2399

);

2400

2401

2402

    #[test]

2403

    fn hover_declarations_stay_conditional_and_the_rest_stay_unconditional() {

2404

        // A hover rule leaking into the unconditional set would permanently paint

2405

        // every inactive tab in the hover colour.

2406

        for style in [

2407

            CSS_MATCH_11510695043643111367,

2408

            CSS_MATCH_13824480602841492081,

2409

            CSS_MATCH_4415083954137121609,

2410

] {

2411

            let conditional = style

2412

                .as_ref()

2413

                .iter()

2414

                .filter(|p| !p.apply_if.as_ref().is_empty())

2415

                .count();

2416

            assert_eq!(

2417

                conditional, 13,

2418

                "each inactive-tab style carries exactly the 13 :hover declarations"

2419

);

2420

2421

2422

        for style in [

2423

            CSS_MATCH_14575853790110873394,

2424

            CSS_MATCH_9988039989460234263,

2425

            CSS_MATCH_17290739305197504468,

2426

            CSS_MATCH_3088386549906605418,

2427

            CSS_MATCH_18014909903571752977,

2428

            CSS_MATCH_18014909903571752977_NO_PADDING,

2429

            CSS_MATCH_4738503469417034630,

2430

            CSS_MATCH_4738503469417034630_NO_PADDING,

2431

] {

2432

            assert!(

2433

                style.as_ref().iter().all(|p| p.apply_if.as_ref().is_empty()),

2434

                "this style must apply unconditionally"

2435

);

2436

2437

2438

2439

    #[test]

2440

    fn dom_datasets_carry_the_position_of_their_tab() {

2441

        for n in [1usize, 2, 5, 1000] {

2442

            let dom = TabHeader::create(numbered_labels(n)).dom();

2443

            let children = dom.children.as_ref();

2444

            for (i, node) in children[1..=n].iter().enumerate() {

2445

                assert_eq!(

2446

                    tab_idx_of(node),

2447

i,

2448

                    "n={n}: tab {i} must carry its own index, not the loop seed"

2449

);

2450

2451

2452

2453

2454

    #[test]

2455

    fn dom_attaches_a_dataset_even_without_a_click_callback() {

2456

        let dom = TabHeader::create(numbered_labels(2)).dom();

2457

        for node in &dom.children.as_ref()[1..=2] {

2458

            assert!(

2459

                node.root.get_dataset().is_some(),

2460

                "the dataset is unconditional (only the callback is not)"

2461

);

2462

            assert!(

2463

                node.root.get_callbacks().as_ref().is_empty(),

2464

                "no callback must be attached when on_click is None"

2465

);

2466

2467

2468

2469

    #[test]

2470

    fn dom_attaches_exactly_one_mouseup_callback_per_tab_when_on_click_is_set() {

2471

        let n = 4usize;

2472

        let dom = TabHeader::create(numbered_labels(n))

2473

            .with_on_click(RefAny::new(ClickLog::default()), cb(record_click))

2474

            .dom();

2475

        let children = dom.children.as_ref();

2476

2477

        for node in &children[1..=n] {

2478

            let cbs = node.root.get_callbacks();

2479

            assert_eq!(cbs.as_ref().len(), 1, "exactly one callback per tab");

2480

            let data = &cbs.as_ref()[0];

2481

            assert_eq!(

2482

                data.event,

2483

                EventFilter::Hover(HoverEventFilter::MouseUp),

2484

                "tabs must react on mouse-up, not mouse-down"

2485

);

2486

            assert_eq!(

2487

                data.callback.cb,

2488

                on_tab_click as usize,

2489

                "the dispatcher must be the widget's own trampoline"

2490

);

2491

2492

2493

        // The spacers must stay inert — a click on the filler must not select.

2494

        assert!(children[0].root.get_callbacks().as_ref().is_empty());

2495

        assert!(children[n + 1].root.get_callbacks().as_ref().is_empty());

2496

2497

2498

    #[test]

2499

    fn dom_keeps_the_estimated_child_count_consistent() {

2500

        // `estimated_total_children` is what sizes the flat arena; a stale value

2501

        // makes `convert_dom_into_compact_dom` under-allocate and panic.

2502

        for n in [0usize, 1, 2, 50] {

2503

            let dom = TabHeader::create(numbered_labels(n)).dom();

2504

            assert_eq!(

2505

                dom.estimated_total_children,

2506

                dom.recompute_estimated_total_children(),

2507

                "n={n}: cached descendant count desynced"

2508

);

2509

            assert_eq!(

2510

                dom.node_count(),

2511

                2 * n + 3,

2512

                "header + spacer + {n} tabs (each a <p> wrapping one text node) + spacer"

2513

);

2514

2515

            let styled = StyledDom::create_from_dom(dom);

2516

            assert_eq!(

2517

                styled.node_hierarchy.as_ref().len(),

2518

                2 * n + 3,

2519

                "n={n}: the flattened arena must match node_count()"

2520

);

2521

2522

2523

2524

    #[test]

2525

    fn dom_releases_every_dataset_clone_when_the_dom_is_dropped() {

2526

        // Each tab clones the user payload into its own `TabLocalDataset`; if the

2527

        // widget leaked one, the app state would outlive the DOM forever.

2528

        for n in [0usize, 1, 5] {

2529

            let user = RefAny::new(ClickLog::default());

2530

            let dom = TabHeader::create(numbered_labels(n))

2531

                .with_on_click(user.clone(), cb(record_click))

2532

                .dom();

2533

2534

            assert_eq!(

2535

                user.get_ref_count(),

2536

                n + 1,

2537

                "n={n}: one payload clone per tab, plus the caller's handle"

2538

);

2539

2540

            drop(dom);

2541

            assert_eq!(

2542

                user.get_ref_count(),

2543

1,

2544

                "n={n}: dropping the DOM must release every payload clone"

2545

);

2546

2547

2548

2549

    #[test]

2550

    fn dom_is_deterministic() {

2551

        let build = || {

2552

            let dom = TabHeader::create(numbered_labels(5))

2553

                .with_active_tab(2)

2554

                .dom();

2555

            let children = dom.children.as_ref();

2556

            let shape: Vec<(Option<String>, Vec<&'static str>)> = children

2557

                .iter()

2558

                .map(|c| (text_of(c).map(str::to_string), class_strs(c)))

2559

                .collect();

2560

            shape

2561

};

2562

        assert_eq!(build(), build(), "dom() must be a pure function of its state");

2563

2564

2565

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

2566

    // TabContent

2567

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

2568

2569

    fn nested(depth: usize) -> Dom {

2570

        let mut dom = Dom::create_text_do_not_use_without_block_level_wrapper("leaf");

2571

        for _ in 0..depth {

2572

            dom = Dom::create_div().with_child(dom);

2573

2574

dom

2575

2576

2577

    #[test]

2578

    fn content_new_defaults_to_padding_and_keeps_the_content_verbatim() {

2579

        let content = nested(3);

2580

        let tab_content = TabContent::new(content.clone());

2581

2582

        assert!(tab_content.has_padding, "new() defaults to padded");

2583

        assert_eq!(

2584

            tab_content.content, content,

2585

            "new() must not rewrap or normalise the content"

2586

);

2587

        assert!(

2588

            TabContent::default().has_padding,

2589

            "Default agrees with new()"

2590

);

2591

2592

2593

    #[test]

2594

    fn with_padding_and_set_padding_agree_and_are_last_wins() {

2595

        for flag in [true, false] {

2596

            let built = TabContent::new(Dom::create_div()).with_padding(flag);

2597

            let mut mutated = TabContent::new(Dom::create_div());

2598

            mutated.set_padding(flag);

2599

            assert_eq!(built.has_padding, flag);

2600

            assert_eq!(built.has_padding, mutated.has_padding);

2601

2602

2603

        let toggled = TabContent::new(Dom::create_div())

2604

            .with_padding(false)

2605

            .with_padding(true)

2606

            .with_padding(false);

2607

        assert!(!toggled.has_padding, "the last write must win");

2608

2609

2610

    #[test]

2611

    fn content_dom_nests_the_content_under_the_content_class() {

2612

        let content = nested(2);

2613

        let dom = TabContent::new(content.clone()).dom();

2614

2615

        assert!(

2616

            class_strs(&dom).is_empty(),

2617

            "the outer wrapper carries the style, not the class"

2618

);

2619

        assert_eq!(dom.children.as_ref().len(), 1, "one wrapper child");

2620

2621

        let inner = &dom.children.as_ref()[0];

2622

        assert_eq!(class_strs(inner), vec![CLASS_CONTENT]);

2623

        assert!(

2624

            inline_declared(inner).is_empty(),

2625

            "the classed node carries no inline style of its own"

2626

);

2627

        assert_eq!(inner.children.as_ref().len(), 1);

2628

        assert_eq!(

2629

            inner.children.as_ref()[0],

2630

            content,

2631

            "the user content must survive the two wrappers untouched"

2632

);

2633

2634

2635

    #[test]

2636

    fn content_dom_picks_the_style_vec_the_padding_flag_asks_for() {

2637

        let padded = TabContent::new(Dom::create_div()).with_padding(true).dom();

2638

        assert_eq!(

2639

            inline_declared(&padded),

2640

            declared(&CSS_MATCH_18014909903571752977)

2641

);

2642

2643

        let bare = TabContent::new(Dom::create_div()).with_padding(false).dom();

2644

        assert_eq!(

2645

            inline_declared(&bare),

2646

            declared(&CSS_MATCH_18014909903571752977_NO_PADDING)

2647

);

2648

2649

        assert_ne!(

2650

            inline_declared(&padded),

2651

            inline_declared(&bare),

2652

            "the two padding modes must not collapse to the same style"

2653

);

2654

2655

2656

    #[test]

2657

    fn the_unpadded_content_style_declares_no_padding_at_all() {

2658

        let padding_decls = decls_where(&CSS_MATCH_18014909903571752977_NO_PADDING, |p| {

2659

            matches!(

2660

p,

2661

                CssProperty::PaddingTop(_)

2662

                    | CssProperty::PaddingBottom(_)

2663

                    | CssProperty::PaddingLeft(_)

2664

                    | CssProperty::PaddingRight(_)

2665

2666

});

2667

        assert!(

2668

            padding_decls.is_empty(),

2669

            "has_padding == false must not leave a padding declaration behind"

2670

);

2671

2672

        let padded = decls_where(&CSS_MATCH_18014909903571752977, |p| {

2673

            matches!(

2674

p,

2675

                CssProperty::PaddingTop(_)

2676

                    | CssProperty::PaddingBottom(_)

2677

                    | CssProperty::PaddingLeft(_)

2678

                    | CssProperty::PaddingRight(_)

2679

2680

});

2681

        assert_eq!(padded.len(), 4, "the padded variant sets all four sides");

2682

2683

2684

    #[test]

2685

    fn content_dom_keeps_the_estimated_child_count_consistent() {

2686

        for depth in [0usize, 1, 3, 64] {

2687

            let content = nested(depth);

2688

            let expected = content.node_count() + 2; // outer wrapper + classed wrapper

2689

            let dom = TabContent::new(content).dom();

2690

2691

            assert_eq!(

2692

                dom.estimated_total_children,

2693

                dom.recompute_estimated_total_children(),

2694

                "depth={depth}: cached descendant count desynced"

2695

);

2696

            assert_eq!(dom.node_count(), expected, "depth={depth}");

2697

2698

            let styled = StyledDom::create_from_dom(dom);

2699

            assert_eq!(

2700

                styled.node_hierarchy.as_ref().len(),

2701

                expected,

2702

                "depth={depth}: the flattened arena must match node_count()"

2703

);

2704

2705

2706

2707

    #[test]

2708

    fn content_swap_with_default_returns_the_old_state_and_leaves_an_empty_div() {

2709

        let content = nested(2);

2710

        let mut tab_content = TabContent::new(content.clone()).with_padding(false);

2711

2712

        let taken = tab_content.swap_with_default();

2713

        assert_eq!(taken.content, content);

2714

        assert!(!taken.has_padding, "the flag moves out with the content");

2715

2716

        assert_eq!(

2717

            tab_content.content,

2718

            Dom::create_div(),

2719

            "the husk must be an empty div"

2720

);

2721

        assert!(

2722

            tab_content.has_padding,

2723

            "the husk is a Default, i.e. padded again"

2724

);

2725

2726

2727

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

2728

    // on_tab_click

2729

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

2730

2731

    #[test]

2732

    fn on_tab_click_reports_the_clicked_index_to_the_user_callback() {

2733

        for idx in [0usize, 1, 7, usize::MAX / 2, usize::MAX - 1, usize::MAX] {

2734

            let mut user = RefAny::new(ClickLog::default());

2735

            let (update, changes) =

2736

                run_click(dataset(idx, click_handler(user.clone(), record_click)));

2737

2738

            assert_eq!(update, Update::RefreshDom);

2739

            assert!(

2740

                changes.is_empty(),

2741

                "the tab handler is stateless — it must not push CallbackChanges"

2742

);

2743

            assert_eq!(

2744

                logged(&mut user),

2745

                vec![TabHeaderState { active_tab: idx }],

2746

                "the index must be forwarded verbatim, without arithmetic"

2747

);

2748

2749

2750

2751

    #[test]

2752

    fn on_tab_click_propagates_the_user_update_verbatim() {

2753

        for (callback, expected) in [

2754

            (record_click as TabOnClickCallbackType, Update::RefreshDom),

2755

            (click_do_nothing, Update::DoNothing),

2756

            (click_refresh_all, Update::RefreshDomAllWindows),

2757

] {

2758

            let (update, _) = run_click(dataset(

2759

3,

2760

                click_handler(RefAny::new(ClickLog::default()), callback),

2761

));

2762

            assert_eq!(update, expected, "the user verdict must not be overridden");

2763

2764

2765

2766

    #[test]

2767

    fn on_tab_click_without_a_user_callback_does_nothing() {

2768

        // A dataset with no `on_click` is reachable only by hand (dom() attaches

2769

        // the trampoline only when a callback exists) — it must stay silent

2770

        // rather than force a relayout.

2771

        let (update, changes) = run_click(dataset(2, None.into()));

2772

        assert_eq!(update, Update::DoNothing);

2773

        assert!(changes.is_empty());

2774

2775

2776

    #[test]

2777

    fn on_tab_click_on_a_foreign_payload_falls_back_to_refresh() {

2778

        // Wrong-typed payload => `downcast_mut` returns None => the documented

2779

        // `unwrap_or(RefreshDom)` fallback. Note this is the *opposite* verdict

2780

        // from the no-callback case above, which is the asymmetry to watch.

2781

        for foreign in [RefAny::new(42u32), RefAny::new(String::from("nope"))] {

2782

            let (update, changes) = run_click(foreign);

2783

            assert_eq!(update, Update::RefreshDom);

2784

            assert!(changes.is_empty());

2785

2786

2787

2788

    #[test]

2789

    fn on_tab_click_declines_while_the_dataset_is_already_borrowed() {

2790

        // Borrow tracking is shared across clones, so a live `Ref` from anywhere

2791

        // must make the handler bail out safely instead of aliasing or panicking.

2792

        let mut held = dataset(1, None.into());

2793

        let clone = held.clone();

2794

        let guard = held

2795

            .downcast_ref::<TabLocalDataset>()

2796

            .expect("the fixture is a TabLocalDataset");

2797

2798

        let (update, changes) = run_click(clone);

2799

        assert_eq!(

2800

            update,

2801

            Update::RefreshDom,

2802

            "a contended dataset must fall back, not panic"

2803

);

2804

        assert!(changes.is_empty());

2805

2806

        drop(guard);

2807

2808

        // ...and the borrow must be released again afterwards.

2809

        let (update, _) = run_click(held.clone());

2810

        assert_eq!(update, Update::DoNothing);

2811

2812

2813

    #[test]

2814

    fn on_tab_click_releases_its_borrow_so_repeated_clicks_keep_working() {

2815

        let mut user = RefAny::new(ClickLog::default());

2816

        let data = dataset(4, click_handler(user.clone(), record_click));

2817

2818

        let (first, _) = run_click(data.clone());

2819

        let (second, _) = run_click(data.clone());

2820

        let (third, _) = run_click(data.clone());

2821

2822

        assert_eq!(

2823

            [first, second, third],

2824

            [Update::RefreshDom; 3],

2825

            "a leaked RefMut would turn later clicks into the RefreshDom fallback \

2826

             without ever reaching the user callback"

2827

);

2828

        assert_eq!(

2829

            logged(&mut user),

2830

            vec![TabHeaderState { active_tab: 4 }; 3],

2831

            "every click must reach the user callback"

2832

);

2833

2834

2835

    #[test]

2836

    fn clicking_a_rendered_tab_selects_that_tab_end_to_end() {

2837

        let n = 5usize;

2838

        let mut user = RefAny::new(ClickLog::default());

2839

        let dom = TabHeader::create(numbered_labels(n))

2840

            .with_on_click(user.clone(), cb(record_click))

2841

            .dom();

2842

2843

        for i in 0..n {

2844

            let data = dom.children.as_ref()[i + 1]

2845

                .root

2846

                .get_callbacks()

2847

                .as_ref()

2848

                .first()

2849

                .expect("every tab carries the click callback")

2850

                .refany

2851

                .clone();

2852

            let (update, changes) = run_click(data);

2853

            assert_eq!(update, Update::RefreshDom);

2854

            assert!(changes.is_empty());

2855

2856

2857

        assert_eq!(

2858

            logged(&mut user),

2859

            (0..n)

2860

                .map(|active_tab| TabHeaderState { active_tab })

2861

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

2862

            "clicking tab i must report exactly i"

2863

);

2864

2865

2866

    #[test]

2867

    fn clicking_a_tab_does_not_move_the_active_tab_by_itself() {

2868

        // The widget is stateless: the handler reports the click and nothing

2869

        // else. Re-rendering the *same* header must therefore keep tab 0 active.

2870

        let user = RefAny::new(ClickLog::default());

2871

        let header = TabHeader::create(numbered_labels(3))

2872

            .with_on_click(user.clone(), cb(record_click));

2873

        let dom = header.clone().dom();

2874

2875

        let data = dom.children.as_ref()[3]

2876

            .root

2877

            .get_callbacks()

2878

            .as_ref()

2879

            .first()

2880

            .expect("tab 2 carries the click callback")

2881

            .refany

2882

            .clone();

2883

        let (update, _) = run_click(data);

2884

        assert_eq!(update, Update::RefreshDom);

2885

2886

        assert_eq!(

2887

            header.active_tab, 0,

2888

            "the header itself must be untouched by a click"

2889

);

2890

        assert_eq!(

2891

            class_strs(&header.dom().children.as_ref()[1]),

2892

            vec![CLASS_ACTIVE],

2893

            "re-rendering the unchanged header keeps tab 0 active"

2894

);

2895

2896